X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Flibrustc%2Fich%2Fimpls_ty.rs;h=563948a63514b300eb4c01a23398aa988ffb452c;hb=93fc627c7d4d15bd45a0a900260897fd9a0bb958;hp=7e0abf752303153c5dda122f546fd780f4a06c88;hpb=d06a020e2b100d8a22252d8877783d8869e5a9ad;p=rust.git

diff --git a/src/librustc/ich/impls_ty.rs b/src/librustc/ich/impls_ty.rs
index 7e0abf75230..563948a6351 100644
--- a/src/librustc/ich/impls_ty.rs
+++ b/src/librustc/ich/impls_ty.rs
@@ -6,11 +6,8 @@
 use rustc_data_structures::stable_hasher::{HashStable, ToStableHashKey,
                                            StableHasher, StableHasherResult};
 use std::cell::RefCell;
-use std::hash as std_hash;
 use std::mem;
 use crate::middle::region;
-use crate::infer;
-use crate::traits;
 use crate::ty;
 use crate::mir;
 
@@ -65,20 +62,6 @@ fn hash_stable<W: StableHasherResult>(&self,
     }
 }
 
-impl<'a, 'gcx> HashStable<StableHashingContext<'a>>
-for ty::subst::UnpackedKind<'gcx> {
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          hcx: &mut StableHashingContext<'a>,
-                                          hasher: &mut StableHasher<W>) {
-        mem::discriminant(self).hash_stable(hcx, hasher);
-        match self {
-            ty::subst::UnpackedKind::Lifetime(lt) => lt.hash_stable(hcx, hasher),
-            ty::subst::UnpackedKind::Type(ty) => ty.hash_stable(hcx, hasher),
-            ty::subst::UnpackedKind::Const(ct) => ct.hash_stable(hcx, hasher),
-        }
-    }
-}
-
 impl<'a> HashStable<StableHashingContext<'a>>
 for ty::RegionKind {
     fn hash_stable<W: StableHasherResult>(&self,
@@ -117,7 +100,6 @@ fn hash_stable<W: StableHasherResult>(&self,
             ty::ReClosureBound(vid) => {
                 vid.hash_stable(hcx, hasher);
             }
-            ty::ReLateBound(..) |
             ty::ReVar(..) |
             ty::RePlaceholder(..) => {
                 bug!("StableHasher: unexpected region {:?}", *self)
@@ -153,105 +135,6 @@ fn hash_stable<W: StableHasherResult>(&self,
     }
 }
 
-impl<'a, 'gcx> HashStable<StableHashingContext<'a>>
-for ty::adjustment::AutoBorrow<'gcx> {
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          hcx: &mut StableHashingContext<'a>,
-                                          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);
-            }
-        }
-    }
-}
-
-impl<'a, 'gcx> HashStable<StableHashingContext<'a>>
-for ty::adjustment::Adjust<'gcx> {
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          hcx: &mut StableHashingContext<'a>,
-                                          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::Unsize => {}
-            ty::adjustment::Adjust::Deref(ref overloaded) => {
-                overloaded.hash_stable(hcx, hasher);
-            }
-            ty::adjustment::Adjust::Borrow(ref autoref) => {
-                autoref.hash_stable(hcx, hasher);
-            }
-        }
-    }
-}
-
-impl_stable_hash_for!(struct ty::adjustment::Adjustment<'tcx> { kind, target });
-impl_stable_hash_for!(struct ty::adjustment::OverloadedDeref<'tcx> { region, mutbl });
-impl_stable_hash_for!(struct ty::UpvarBorrow<'tcx> { kind, region });
-impl_stable_hash_for!(enum ty::adjustment::AllowTwoPhase {
-    Yes,
-    No
-});
-
-impl<'gcx> HashStable<StableHashingContext<'gcx>> for ty::adjustment::AutoBorrowMutability {
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          hcx: &mut StableHashingContext<'gcx>,
-                                          hasher: &mut StableHasher<W>) {
-        mem::discriminant(self).hash_stable(hcx, hasher);
-        match *self {
-            ty::adjustment::AutoBorrowMutability::Mutable { ref allow_two_phase_borrow } => {
-                allow_two_phase_borrow.hash_stable(hcx, hasher);
-            }
-            ty::adjustment::AutoBorrowMutability::Immutable => {}
-        }
-    }
-}
-
-impl_stable_hash_for!(tuple_struct ty::util::NeedsDrop { value });
-
-impl_stable_hash_for!(tuple_struct ty::AdtSizedConstraint<'tcx> { list });
-
-impl_stable_hash_for!(struct ty::UpvarPath { hir_id });
-
-impl_stable_hash_for!(struct ty::UpvarId { var_path, closure_expr_id });
-
-impl_stable_hash_for!(enum ty::BorrowKind {
-    ImmBorrow,
-    UniqueImmBorrow,
-    MutBorrow
-});
-
-impl_stable_hash_for!(impl<'gcx> for enum ty::UpvarCapture<'gcx> [ ty::UpvarCapture ] {
-    ByValue,
-    ByRef(up_var_borrow),
-});
-
-impl_stable_hash_for!(struct ty::GenSig<'tcx> {
-    yield_ty,
-    return_ty
-});
-
-impl_stable_hash_for!(struct ty::FnSig<'tcx> {
-    inputs_and_output,
-    c_variadic,
-    unsafety,
-    abi
-});
-
-impl_stable_hash_for!(struct ty::ResolvedOpaqueTy<'tcx> {
-    concrete_type,
-    substs
-});
-
 impl<'a, 'gcx, T> HashStable<StableHashingContext<'a>> for ty::Binder<T>
     where T: HashStable<StableHashingContext<'a>>
 {
@@ -262,108 +145,6 @@ fn hash_stable<W: StableHasherResult>(&self,
     }
 }
 
-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!(struct ty::SubtypePredicate<'tcx> { a_is_expected, a, b });
-impl_stable_hash_for!(impl<A, B> for tuple_struct ty::OutlivesPredicate<A, B> { a, b });
-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!(
-    impl<'tcx> for enum ty::Predicate<'tcx> [ ty::Predicate ] {
-        Trait(pred),
-        Subtype(pred),
-        RegionOutlives(pred),
-        TypeOutlives(pred),
-        Projection(pred),
-        WellFormed(ty),
-        ObjectSafe(def_id),
-        ClosureKind(def_id, closure_substs, closure_kind),
-        ConstEvaluatable(def_id, substs),
-    }
-);
-
-impl<'a> HashStable<StableHashingContext<'a>> for ty::AdtFlags {
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          _: &mut StableHashingContext<'a>,
-                                          hasher: &mut StableHasher<W>) {
-        std_hash::Hash::hash(self, hasher);
-    }
-}
-
-impl<'a> HashStable<StableHashingContext<'a>> for ty::VariantFlags {
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          _: &mut StableHashingContext<'a>,
-                                          hasher: &mut StableHasher<W>) {
-        std_hash::Hash::hash(self, hasher);
-    }
-}
-
-impl_stable_hash_for!(
-    impl<'tcx> for enum ty::InferConst<'tcx> [ ty::InferConst ] {
-        Var(vid),
-        Fresh(i),
-        Canonical(debruijn, var),
-    }
-);
-
-impl_stable_hash_for!(enum ty::VariantDiscr {
-    Explicit(def_id),
-    Relative(distance)
-});
-
-impl_stable_hash_for!(struct ty::FieldDef {
-    did,
-    ident -> (ident.name),
-    vis,
-});
-
-impl_stable_hash_for!(
-    impl<'tcx> for enum mir::interpret::ConstValue<'tcx> [ mir::interpret::ConstValue ] {
-        Param(param),
-        Infer(infer),
-        Scalar(val),
-        Slice(a, b),
-        ByRef(ptr, alloc),
-    }
-);
-
-impl_stable_hash_for!(struct crate::mir::interpret::RawConst<'tcx> {
-    alloc_id,
-    ty,
-});
-
-impl_stable_hash_for! {
-    impl<Tag> for struct mir::interpret::Pointer<Tag> {
-        alloc_id,
-        offset,
-        tag,
-    }
-}
-
-impl_stable_hash_for!(
-    impl<Tag> for enum mir::interpret::Scalar<Tag> [ mir::interpret::Scalar ] {
-        Bits { bits, size },
-        Ptr(ptr),
-    }
-);
-
-impl_stable_hash_for!(
-    impl<'tcx> for enum mir::interpret::AllocKind<'tcx> [ mir::interpret::AllocKind ] {
-        Function(instance),
-        Static(def_id),
-        Memory(mem),
-    }
-);
-
 // AllocIds get resolved to whatever they point to (to be stable)
 impl<'a> HashStable<StableHashingContext<'a>> for mir::interpret::AllocId {
     fn hash_stable<W: StableHasherResult>(
@@ -402,194 +183,6 @@ fn hash_stable<W: StableHasherResult>(
     Mutable
 });
 
-impl_stable_hash_for!(struct ty::Const<'tcx> {
-    ty,
-    val
-});
-
-impl_stable_hash_for!(impl<'tcx> for enum ty::LazyConst<'tcx> [ty::LazyConst] {
-    Unevaluated(did, substs),
-    Evaluated(c)
-});
-
-impl_stable_hash_for!(enum mir::interpret::ErrorHandled {
-    Reported,
-    TooGeneric
-});
-
-impl_stable_hash_for!(struct mir::interpret::FrameInfo<'tcx> {
-    call_site,
-    lint_root,
-    instance
-});
-
-impl_stable_hash_for!(struct ty::ClosureSubsts<'tcx> { substs });
-impl_stable_hash_for!(struct ty::GeneratorSubsts<'tcx> { substs });
-
-impl_stable_hash_for!(struct ty::GenericPredicates<'tcx> {
-    parent,
-    predicates
-});
-
-impl_stable_hash_for!(
-    impl<'tcx, O> for enum mir::interpret::EvalErrorKind<'tcx, O>
-        [ mir::interpret::EvalErrorKind ]
-    {
-        FunctionArgCountMismatch,
-        DanglingPointerDeref,
-        DoubleFree,
-        InvalidMemoryAccess,
-        InvalidFunctionPointer,
-        InvalidBool,
-        InvalidNullPointerUsage,
-        ReadPointerAsBytes,
-        ReadBytesAsPointer,
-        ReadForeignStatic,
-        InvalidPointerMath,
-        DeadLocal,
-        StackFrameLimitReached,
-        OutOfTls,
-        TlsOutOfBounds,
-        CalledClosureAsFunction,
-        VtableForArgumentlessMethod,
-        ModifiedConstantMemory,
-        ModifiedStatic,
-        AssumptionNotHeld,
-        InlineAsm,
-        ReallocateNonBasePtr,
-        DeallocateNonBasePtr,
-        HeapAllocZeroBytes,
-        Unreachable,
-        ReadFromReturnPointer,
-        UnimplementedTraitSelection,
-        TypeckError,
-        TooGeneric,
-        DerefFunctionPointer,
-        ExecuteMemory,
-        OverflowNeg,
-        RemainderByZero,
-        DivisionByZero,
-        GeneratorResumedAfterReturn,
-        GeneratorResumedAfterPanic,
-        ReferencedConstant,
-        InfiniteLoop,
-        ReadUndefBytes(offset),
-        InvalidDiscriminant(val),
-        Panic { msg, file, line, col },
-        MachineError(err),
-        FunctionAbiMismatch(a, b),
-        FunctionArgMismatch(a, b),
-        FunctionRetMismatch(a, b),
-        NoMirFor(s),
-        UnterminatedCString(ptr),
-        PointerOutOfBounds { ptr, check, allocation_size },
-        InvalidBoolOp(bop),
-        Unimplemented(s),
-        BoundsCheck { len, index },
-        Intrinsic(s),
-        InvalidChar(c),
-        AbiViolation(s),
-        AlignmentCheckFailed { required, has },
-        ValidationFailure(s),
-        TypeNotPrimitive(ty),
-        ReallocatedWrongMemoryKind(a, b),
-        DeallocatedWrongMemoryKind(a, b),
-        IncorrectAllocationInformation(a, b, c, d),
-        Layout(lay),
-        HeapAllocNonPowerOfTwoAlignment(n),
-        PathNotFound(v),
-        Overflow(op),
-    }
-);
-
-impl_stable_hash_for!(enum mir::interpret::InboundsCheck {
-    Live,
-    MaybeDead
-});
-
-impl_stable_hash_for!(enum ty::Variance {
-    Covariant,
-    Invariant,
-    Contravariant,
-    Bivariant
-});
-
-impl_stable_hash_for!(enum ty::adjustment::CustomCoerceUnsized {
-    Struct(index)
-});
-
-impl_stable_hash_for!(struct ty::Generics {
-    parent,
-    parent_count,
-    params,
-    // Reverse map to each param's `index` field, from its `def_id`.
-    param_def_id_to_index -> _, // Don't hash this
-    has_self,
-    has_late_bound_regions,
-});
-
-impl_stable_hash_for!(struct ty::GenericParamDef {
-    name,
-    def_id,
-    index,
-    pure_wrt_drop,
-    kind
-});
-
-impl_stable_hash_for!(enum ty::GenericParamDefKind {
-    Lifetime,
-    Type { has_default, object_lifetime_default, synthetic },
-    Const,
-});
-
-impl_stable_hash_for!(
-    impl<T> for enum crate::middle::resolve_lifetime::Set1<T>
-        [ crate::middle::resolve_lifetime::Set1 ]
-    {
-        Empty,
-        Many,
-        One(value),
-    }
-);
-
-impl_stable_hash_for!(enum crate::middle::resolve_lifetime::LifetimeDefOrigin {
-    ExplicitOrElided,
-    InBand,
-    Error,
-});
-
-impl_stable_hash_for!(enum crate::middle::resolve_lifetime::Region {
-    Static,
-    EarlyBound(index, decl, is_in_band),
-    LateBound(db_index, decl, is_in_band),
-    LateBoundAnon(db_index, anon_index),
-    Free(call_site_scope_data, decl)
-});
-
-impl_stable_hash_for!(enum ty::cast::CastKind {
-    CoercionCast,
-    PtrPtrCast,
-    PtrAddrCast,
-    AddrPtrCast,
-    NumericCast,
-    EnumCast,
-    PrimIntCast,
-    U8CharCast,
-    ArrayPtrCast,
-    FnPtrPtrCast,
-    FnPtrAddrCast
-});
-
-impl_stable_hash_for!(struct crate::middle::region::Scope { id, data });
-
-impl_stable_hash_for!(enum crate::middle::region::ScopeData {
-    Node,
-    CallSite,
-    Arguments,
-    Destruction,
-    Remainder(first_statement_index)
-});
-
 impl<'a> ToStableHashKey<StableHashingContext<'a>> for region::Scope {
     type KeyType = region::Scope;
 
@@ -599,129 +192,6 @@ fn to_stable_hash_key(&self, _: &StableHashingContext<'a>) -> region::Scope {
     }
 }
 
-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, 'gcx> HashStable<StableHashingContext<'a>>
-for ty::TyKind<'gcx>
-{
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          hcx: &mut StableHashingContext<'a>,
-                                          hasher: &mut StableHasher<W>) {
-        use crate::ty::TyKind::*;
-
-        mem::discriminant(self).hash_stable(hcx, hasher);
-        match *self {
-            Bool  |
-            Char  |
-            Str   |
-            Error |
-            Never => {
-                // Nothing more to hash.
-            }
-            Int(int_ty) => {
-                int_ty.hash_stable(hcx, hasher);
-            }
-            Uint(uint_ty) => {
-                uint_ty.hash_stable(hcx, hasher);
-            }
-            Float(float_ty)  => {
-                float_ty.hash_stable(hcx, hasher);
-            }
-            Adt(adt_def, substs) => {
-                adt_def.hash_stable(hcx, hasher);
-                substs.hash_stable(hcx, hasher);
-            }
-            Array(inner_ty, len) => {
-                inner_ty.hash_stable(hcx, hasher);
-                len.hash_stable(hcx, hasher);
-            }
-            Slice(inner_ty) => {
-                inner_ty.hash_stable(hcx, hasher);
-            }
-            RawPtr(pointee_ty) => {
-                pointee_ty.hash_stable(hcx, hasher);
-            }
-            Ref(region, pointee_ty, mutbl) => {
-                region.hash_stable(hcx, hasher);
-                pointee_ty.hash_stable(hcx, hasher);
-                mutbl.hash_stable(hcx, hasher);
-            }
-            FnDef(def_id, substs) => {
-                def_id.hash_stable(hcx, hasher);
-                substs.hash_stable(hcx, hasher);
-            }
-            FnPtr(ref sig) => {
-                sig.hash_stable(hcx, hasher);
-            }
-            Dynamic(ref existential_predicates, region) => {
-                existential_predicates.hash_stable(hcx, hasher);
-                region.hash_stable(hcx, hasher);
-            }
-            Closure(def_id, closure_substs) => {
-                def_id.hash_stable(hcx, hasher);
-                closure_substs.hash_stable(hcx, hasher);
-            }
-            Generator(def_id, generator_substs, movability) => {
-                def_id.hash_stable(hcx, hasher);
-                generator_substs.hash_stable(hcx, hasher);
-                movability.hash_stable(hcx, hasher);
-            }
-            GeneratorWitness(types) => {
-                types.hash_stable(hcx, hasher)
-            }
-            Tuple(inner_tys) => {
-                inner_tys.hash_stable(hcx, hasher);
-            }
-            Projection(ref data) | UnnormalizedProjection(ref data) => {
-                data.hash_stable(hcx, hasher);
-            }
-            Opaque(def_id, substs) => {
-                def_id.hash_stable(hcx, hasher);
-                substs.hash_stable(hcx, hasher);
-            }
-            Param(param_ty) => {
-                param_ty.hash_stable(hcx, hasher);
-            }
-            Bound(debruijn, bound_ty) => {
-                debruijn.hash_stable(hcx, hasher);
-                bound_ty.hash_stable(hcx, hasher);
-            }
-            ty::Placeholder(placeholder_ty) => {
-                placeholder_ty.hash_stable(hcx, hasher);
-            }
-            Foreign(def_id) => {
-                def_id.hash_stable(hcx, hasher);
-            }
-            Infer(infer_ty) => {
-                infer_ty.hash_stable(hcx, hasher);
-            }
-        }
-    }
-}
-
-impl_stable_hash_for!(enum ty::InferTy {
-    TyVar(a),
-    IntVar(a),
-    FloatVar(a),
-    FreshTy(a),
-    FreshIntTy(a),
-    FreshFloatTy(a),
-});
-
 impl<'a, 'gcx> HashStable<StableHashingContext<'a>>
 for ty::TyVid
 {
@@ -758,146 +228,6 @@ fn hash_stable<W: StableHasherResult>(&self,
     }
 }
 
-impl_stable_hash_for!(struct ty::ParamConst {
-    index,
-    name
-});
-
-impl_stable_hash_for!(struct ty::ParamTy {
-    idx,
-    name
-});
-
-impl_stable_hash_for!(struct ty::TypeAndMut<'tcx> {
-    ty,
-    mutbl
-});
-
-impl<'a, 'gcx> HashStable<StableHashingContext<'a>>
-for ty::ExistentialPredicate<'gcx>
-{
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          hcx: &mut StableHashingContext<'a>,
-                                          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> {
-    item_def_id,
-    substs,
-    ty
-});
-
-impl_stable_hash_for!(struct ty::Instance<'tcx> {
-    def,
-    substs
-});
-
-impl<'a, 'gcx> HashStable<StableHashingContext<'a>> for ty::InstanceDef<'gcx> {
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          hcx: &mut StableHashingContext<'a>,
-                                          hasher: &mut StableHasher<W>) {
-        mem::discriminant(self).hash_stable(hcx, hasher);
-
-        match *self {
-            ty::InstanceDef::Item(def_id) => {
-                def_id.hash_stable(hcx, hasher);
-            }
-            ty::InstanceDef::VtableShim(def_id) => {
-                def_id.hash_stable(hcx, hasher);
-            }
-            ty::InstanceDef::Intrinsic(def_id) => {
-                def_id.hash_stable(hcx, hasher);
-            }
-            ty::InstanceDef::FnPtrShim(def_id, ty) => {
-                def_id.hash_stable(hcx, hasher);
-                ty.hash_stable(hcx, hasher);
-            }
-            ty::InstanceDef::Virtual(def_id, n) => {
-                def_id.hash_stable(hcx, hasher);
-                n.hash_stable(hcx, hasher);
-            }
-            ty::InstanceDef::ClosureOnceShim { call_once } => {
-                call_once.hash_stable(hcx, hasher);
-            }
-            ty::InstanceDef::DropGlue(def_id, ty) => {
-                def_id.hash_stable(hcx, hasher);
-                ty.hash_stable(hcx, hasher);
-            }
-            ty::InstanceDef::CloneShim(def_id, ty) => {
-                def_id.hash_stable(hcx, hasher);
-                ty.hash_stable(hcx, hasher);
-            }
-        }
-    }
-}
-
-impl_stable_hash_for!(struct ty::TraitDef {
-    // We already have the def_path_hash below, no need to hash it twice
-    def_id -> _,
-    unsafety,
-    paren_sugar,
-    has_auto_impl,
-    is_marker,
-    def_path_hash,
-});
-
-impl_stable_hash_for!(struct ty::Destructor {
-    did
-});
-
-impl_stable_hash_for!(struct ty::CrateVariancesMap {
-    variances,
-    // This is just an irrelevant helper value.
-    empty_variance -> _,
-});
-
-impl_stable_hash_for!(struct ty::CratePredicatesMap<'tcx> {
-    predicates,
-    // This is just an irrelevant helper value.
-    empty_predicate -> _,
-});
-
-impl_stable_hash_for!(struct ty::AssociatedItem {
-    def_id,
-    ident -> (ident.name),
-    kind,
-    vis,
-    defaultness,
-    container,
-    method_has_self_argument
-});
-
-impl_stable_hash_for!(enum ty::AssociatedKind {
-    Const,
-    Method,
-    Existential,
-    Type
-});
-
-impl_stable_hash_for!(enum ty::AssociatedItemContainer {
-    TraitContainer(def_id),
-    ImplContainer(def_id)
-});
-
-
 impl<'a, 'gcx, T> HashStable<StableHashingContext<'a>>
 for ty::steal::Steal<T>
     where T: HashStable<StableHashingContext<'a>>
@@ -909,24 +239,6 @@ fn hash_stable<W: StableHasherResult>(&self,
     }
 }
 
-impl_stable_hash_for!(struct ty::ParamEnv<'tcx> {
-    caller_bounds,
-    reveal,
-    def_id
-});
-
-impl_stable_hash_for!(enum traits::Reveal {
-    UserFacing,
-    All
-});
-
-impl_stable_hash_for!(enum crate::middle::privacy::AccessLevel {
-    ReachableFromImplTrait,
-    Reachable,
-    Exported,
-    Public
-});
-
 impl<'a> HashStable<StableHashingContext<'a>>
 for crate::middle::privacy::AccessLevels {
     fn hash_stable<W: StableHasherResult>(&self,
@@ -941,366 +253,3 @@ fn hash_stable<W: StableHasherResult>(&self,
         });
     }
 }
-
-impl_stable_hash_for!(struct ty::CrateInherentImpls {
-    inherent_impls
-});
-
-impl_stable_hash_for!(struct crate::util::common::ErrorReported {});
-
-impl_stable_hash_for!(tuple_struct crate::middle::reachable::ReachableSet {
-    reachable_set
-});
-
-impl<'a, 'gcx, N> HashStable<StableHashingContext<'a>>
-for traits::Vtable<'gcx, N> where N: HashStable<StableHashingContext<'a>> {
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          hcx: &mut StableHashingContext<'a>,
-                                          hasher: &mut StableHasher<W>) {
-        use crate::traits::Vtable::*;
-
-        mem::discriminant(self).hash_stable(hcx, hasher);
-
-        match self {
-            &VtableImpl(ref table_impl) => table_impl.hash_stable(hcx, hasher),
-            &VtableAutoImpl(ref table_def_impl) => table_def_impl.hash_stable(hcx, hasher),
-            &VtableParam(ref table_param) => table_param.hash_stable(hcx, hasher),
-            &VtableObject(ref table_obj) => table_obj.hash_stable(hcx, hasher),
-            &VtableBuiltin(ref table_builtin) => table_builtin.hash_stable(hcx, hasher),
-            &VtableClosure(ref table_closure) => table_closure.hash_stable(hcx, hasher),
-            &VtableFnPointer(ref table_fn_pointer) => table_fn_pointer.hash_stable(hcx, hasher),
-            &VtableGenerator(ref table_generator) => table_generator.hash_stable(hcx, hasher),
-            &VtableTraitAlias(ref table_alias) => table_alias.hash_stable(hcx, hasher),
-        }
-    }
-}
-
-impl<'a, 'gcx, N> HashStable<StableHashingContext<'a>>
-for traits::VtableImplData<'gcx, N> where N: HashStable<StableHashingContext<'a>> {
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          hcx: &mut StableHashingContext<'a>,
-                                          hasher: &mut StableHasher<W>) {
-        let traits::VtableImplData {
-            impl_def_id,
-            substs,
-            ref nested,
-        } = *self;
-        impl_def_id.hash_stable(hcx, hasher);
-        substs.hash_stable(hcx, hasher);
-        nested.hash_stable(hcx, hasher);
-    }
-}
-
-impl<'a, 'gcx, N> HashStable<StableHashingContext<'a>>
-for traits::VtableAutoImplData<N> where N: HashStable<StableHashingContext<'a>> {
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          hcx: &mut StableHashingContext<'a>,
-                                          hasher: &mut StableHasher<W>) {
-        let traits::VtableAutoImplData {
-            trait_def_id,
-            ref nested,
-        } = *self;
-        trait_def_id.hash_stable(hcx, hasher);
-        nested.hash_stable(hcx, hasher);
-    }
-}
-
-impl<'a, 'gcx, N> HashStable<StableHashingContext<'a>>
-for traits::VtableObjectData<'gcx, N> where N: HashStable<StableHashingContext<'a>> {
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          hcx: &mut StableHashingContext<'a>,
-                                          hasher: &mut StableHasher<W>) {
-        let traits::VtableObjectData {
-            upcast_trait_ref,
-            vtable_base,
-            ref nested,
-        } = *self;
-        upcast_trait_ref.hash_stable(hcx, hasher);
-        vtable_base.hash_stable(hcx, hasher);
-        nested.hash_stable(hcx, hasher);
-    }
-}
-
-impl<'a, 'gcx, N> HashStable<StableHashingContext<'a>>
-for traits::VtableBuiltinData<N> where N: HashStable<StableHashingContext<'a>> {
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          hcx: &mut StableHashingContext<'a>,
-                                          hasher: &mut StableHasher<W>) {
-        let traits::VtableBuiltinData {
-            ref nested,
-        } = *self;
-        nested.hash_stable(hcx, hasher);
-    }
-}
-
-impl<'a, 'gcx, N> HashStable<StableHashingContext<'a>>
-for traits::VtableClosureData<'gcx, N> where N: HashStable<StableHashingContext<'a>> {
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          hcx: &mut StableHashingContext<'a>,
-                                          hasher: &mut StableHasher<W>) {
-        let traits::VtableClosureData {
-            closure_def_id,
-            substs,
-            ref nested,
-        } = *self;
-        closure_def_id.hash_stable(hcx, hasher);
-        substs.hash_stable(hcx, hasher);
-        nested.hash_stable(hcx, hasher);
-    }
-}
-
-impl<'a, 'gcx, N> HashStable<StableHashingContext<'a>>
-for traits::VtableFnPointerData<'gcx, N> where N: HashStable<StableHashingContext<'a>> {
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          hcx: &mut StableHashingContext<'a>,
-                                          hasher: &mut StableHasher<W>) {
-        let traits::VtableFnPointerData {
-            fn_ty,
-            ref nested,
-        } = *self;
-        fn_ty.hash_stable(hcx, hasher);
-        nested.hash_stable(hcx, hasher);
-    }
-}
-
-impl<'a, 'gcx, N> HashStable<StableHashingContext<'a>>
-for traits::VtableGeneratorData<'gcx, N> where N: HashStable<StableHashingContext<'a>> {
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          hcx: &mut StableHashingContext<'a>,
-                                          hasher: &mut StableHasher<W>) {
-        let traits::VtableGeneratorData {
-            generator_def_id,
-            substs,
-            ref nested,
-        } = *self;
-        generator_def_id.hash_stable(hcx, hasher);
-        substs.hash_stable(hcx, hasher);
-        nested.hash_stable(hcx, hasher);
-    }
-}
-
-impl<'a, 'gcx, N> HashStable<StableHashingContext<'a>>
-for traits::VtableTraitAliasData<'gcx, N> where N: HashStable<StableHashingContext<'a>> {
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          hcx: &mut StableHashingContext<'a>,
-                                          hasher: &mut StableHasher<W>) {
-        let traits::VtableTraitAliasData {
-            alias_def_id,
-            substs,
-            ref nested,
-        } = *self;
-        alias_def_id.hash_stable(hcx, hasher);
-        substs.hash_stable(hcx, hasher);
-        nested.hash_stable(hcx, hasher);
-    }
-}
-
-impl_stable_hash_for!(
-    impl<'tcx, V> for struct infer::canonical::Canonical<'tcx, V> {
-        max_universe, variables, value
-    }
-);
-
-impl_stable_hash_for!(
-    struct infer::canonical::CanonicalVarValues<'tcx> {
-        var_values
-    }
-);
-
-impl_stable_hash_for!(struct infer::canonical::CanonicalVarInfo {
-    kind
-});
-
-impl_stable_hash_for!(enum infer::canonical::CanonicalVarKind {
-    Ty(k),
-    PlaceholderTy(placeholder),
-    Region(ui),
-    PlaceholderRegion(placeholder),
-});
-
-impl_stable_hash_for!(enum infer::canonical::CanonicalTyVarKind {
-    General(ui),
-    Int,
-    Float
-});
-
-impl_stable_hash_for!(
-    impl<'tcx, R> for struct infer::canonical::QueryResponse<'tcx, R> {
-        var_values, region_constraints, certainty, value
-    }
-);
-
-impl_stable_hash_for!(enum infer::canonical::Certainty {
-    Proven, Ambiguous
-});
-
-impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for traits::WhereClause<'tcx> {
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          hcx: &mut StableHashingContext<'a>,
-                                          hasher: &mut StableHasher<W>) {
-        use crate::traits::WhereClause::*;
-
-        mem::discriminant(self).hash_stable(hcx, hasher);
-        match self {
-            Implemented(trait_ref) => trait_ref.hash_stable(hcx, hasher),
-            ProjectionEq(projection) => projection.hash_stable(hcx, hasher),
-            TypeOutlives(ty_outlives) => ty_outlives.hash_stable(hcx, hasher),
-            RegionOutlives(region_outlives) => region_outlives.hash_stable(hcx, hasher),
-        }
-    }
-}
-
-impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for traits::WellFormed<'tcx> {
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          hcx: &mut StableHashingContext<'a>,
-                                          hasher: &mut StableHasher<W>) {
-        use crate::traits::WellFormed::*;
-
-        mem::discriminant(self).hash_stable(hcx, hasher);
-        match self {
-            Trait(trait_ref) => trait_ref.hash_stable(hcx, hasher),
-            Ty(ty) => ty.hash_stable(hcx, hasher),
-        }
-    }
-}
-
-impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for traits::FromEnv<'tcx> {
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          hcx: &mut StableHashingContext<'a>,
-                                          hasher: &mut StableHasher<W>) {
-        use crate::traits::FromEnv::*;
-
-        mem::discriminant(self).hash_stable(hcx, hasher);
-        match self {
-            Trait(trait_ref) => trait_ref.hash_stable(hcx, hasher),
-            Ty(ty) => ty.hash_stable(hcx, hasher),
-        }
-    }
-}
-
-impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for traits::DomainGoal<'tcx> {
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          hcx: &mut StableHashingContext<'a>,
-                                          hasher: &mut StableHasher<W>) {
-        use crate::traits::DomainGoal::*;
-
-        mem::discriminant(self).hash_stable(hcx, hasher);
-        match self {
-            Holds(wc) => wc.hash_stable(hcx, hasher),
-            WellFormed(wf) => wf.hash_stable(hcx, hasher),
-            FromEnv(from_env) => from_env.hash_stable(hcx, hasher),
-            Normalize(projection) => projection.hash_stable(hcx, hasher),
-        }
-    }
-}
-
-impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for traits::Goal<'tcx> {
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          hcx: &mut StableHashingContext<'a>,
-                                          hasher: &mut StableHasher<W>) {
-        use crate::traits::GoalKind::*;
-
-        mem::discriminant(self).hash_stable(hcx, hasher);
-        match self {
-            Implies(hypotheses, goal) => {
-                hypotheses.hash_stable(hcx, hasher);
-                goal.hash_stable(hcx, hasher);
-            },
-            And(goal1, goal2) => {
-                goal1.hash_stable(hcx, hasher);
-                goal2.hash_stable(hcx, hasher);
-            }
-            Not(goal) => goal.hash_stable(hcx, hasher),
-            DomainGoal(domain_goal) => domain_goal.hash_stable(hcx, hasher),
-            Quantified(quantifier, goal) => {
-                quantifier.hash_stable(hcx, hasher);
-                goal.hash_stable(hcx, hasher);
-            },
-            Subtype(a, b) => {
-                a.hash_stable(hcx, hasher);
-                b.hash_stable(hcx, hasher);
-            }
-            CannotProve => { },
-        }
-    }
-}
-
-impl_stable_hash_for!(
-    struct traits::ProgramClause<'tcx> {
-        goal, hypotheses, category
-    }
-);
-
-impl_stable_hash_for!(enum traits::ProgramClauseCategory {
-    ImpliedBound,
-    WellFormed,
-    Other,
-});
-
-impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for traits::Clause<'tcx> {
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          hcx: &mut StableHashingContext<'a>,
-                                          hasher: &mut StableHasher<W>) {
-        use crate::traits::Clause::*;
-
-        mem::discriminant(self).hash_stable(hcx, hasher);
-        match self {
-            Implies(clause) => clause.hash_stable(hcx, hasher),
-            ForAll(clause) => clause.hash_stable(hcx, hasher),
-        }
-    }
-}
-
-impl_stable_hash_for!(enum traits::QuantifierKind {
-    Universal,
-    Existential
-});
-
-impl_stable_hash_for!(struct ty::subst::UserSubsts<'tcx> { substs, user_self_ty });
-
-impl_stable_hash_for!(struct ty::subst::UserSelfTy<'tcx> { impl_def_id, self_ty });
-
-impl_stable_hash_for!(
-    struct traits::Environment<'tcx> {
-        clauses,
-    }
-);
-
-impl_stable_hash_for!(
-    impl<'tcx, G> for struct traits::InEnvironment<'tcx, G> {
-        environment,
-        goal,
-    }
-);
-
-impl_stable_hash_for!(
-    struct ty::CanonicalUserTypeAnnotation<'tcx> {
-        user_ty, span, inferred_ty
-    }
-);
-
-impl<'a, 'gcx> HashStable<StableHashingContext<'a>> for ty::UserType<'gcx> {
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          hcx: &mut StableHashingContext<'a>,
-                                          hasher: &mut StableHasher<W>) {
-        mem::discriminant(self).hash_stable(hcx, hasher);
-        match *self {
-            ty::UserType::Ty(ref ty) => {
-                ty.hash_stable(hcx, hasher);
-            }
-            ty::UserType::TypeOf(ref def_id, ref substs) => {
-                def_id.hash_stable(hcx, hasher);
-                substs.hash_stable(hcx, hasher);
-            }
-        }
-    }
-}
-
-impl<'a> HashStable<StableHashingContext<'a>> for ty::UserTypeAnnotationIndex {
-    #[inline]
-    fn hash_stable<W: StableHasherResult>(&self,
-                                          hcx: &mut StableHashingContext<'a>,
-                                          hasher: &mut StableHasher<W>) {
-        self.index().hash_stable(hcx, hasher);
-    }
-}