src/librustc/ich/impls_ty.rs

   1 // Copyright 2017 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 //! This module contains `HashStable` implementations for various data types
  12 //! from rustc::ty in no particular order.
  13
  14 use ich::{self, StableHashingContext, NodeIdHashingMode};
  15 use rustc_data_structures::stable_hasher::{HashStable, StableHasher,
  16                                            StableHasherResult};
  17 use std::hash as std_hash;
  18 use std::mem;
  19 use syntax_pos::symbol::InternedString;
  20 use ty;
  21
  22 impl_stable_hash_for!(struct ty::ItemSubsts<'tcx> { substs });
  23
  24 impl<'a, 'tcx, T> HashStable<StableHashingContext<'a, 'tcx>> for &'tcx ty::Slice<T>
  25     where T: HashStable<StableHashingContext<'a, 'tcx>> {
  26     fn hash_stable<W: StableHasherResult>(&self,
  27                                           hcx: &mut StableHashingContext<'a, 'tcx>,
  28                                           hasher: &mut StableHasher<W>) {
  29         (&self[..]).hash_stable(hcx, hasher);
  30     }
  31 }
  32
  33 impl<'a, 'tcx> HashStable<StableHashingContext<'a, 'tcx>> for ty::subst::Kind<'tcx> {
  34     fn hash_stable<W: StableHasherResult>(&self,
  35                                           hcx: &mut StableHashingContext<'a, 'tcx>,
  36                                           hasher: &mut StableHasher<W>) {
  37         self.as_type().hash_stable(hcx, hasher);
  38         self.as_region().hash_stable(hcx, hasher);
  39     }
  40 }
  41
  42 impl<'a, 'tcx> HashStable<StableHashingContext<'a, 'tcx>> for ty::RegionKind<'tcx> {
  43     fn hash_stable<W: StableHasherResult>(&self,
  44                                           hcx: &mut StableHashingContext<'a, 'tcx>,
  45                                           hasher: &mut StableHasher<W>) {
  46         mem::discriminant(self).hash_stable(hcx, hasher);
  47         match *self {
  48             ty::ReErased |
  49             ty::ReStatic |
  50             ty::ReEmpty => {
  51                 // No variant fields to hash for these ...
  52             }
  53             ty::ReLateBound(db, ty::BrAnon(i)) => {
  54                 db.depth.hash_stable(hcx, hasher);
  55                 i.hash_stable(hcx, hasher);
  56             }
  57             ty::ReEarlyBound(ty::EarlyBoundRegion { index, name }) => {
  58                 index.hash_stable(hcx, hasher);
  59                 name.hash_stable(hcx, hasher);
  60             }
  61             ty::ReScope(code_extent) => {
  62                 code_extent.hash_stable(hcx, hasher);
  63             }
  64             ty::ReFree(ref free_region) => {
  65                 free_region.hash_stable(hcx, hasher);
  66             }
  67             ty::ReLateBound(..) |
  68             ty::ReVar(..) |
  69             ty::ReSkolemized(..) => {
  70                 bug!("TypeIdHasher: unexpected region {:?}", *self)
  71             }
  72         }
  73     }
  74 }
  75
  76 impl<'a, 'tcx> HashStable<StableHashingContext<'a, 'tcx>> for ty::adjustment::AutoBorrow<'tcx> {
  77     fn hash_stable<W: StableHasherResult>(&self,
  78                                           hcx: &mut StableHashingContext<'a, 'tcx>,
  79                                           hasher: &mut StableHasher<W>) {
  80         mem::discriminant(self).hash_stable(hcx, hasher);
  81         match *self {
  82             ty::adjustment::AutoBorrow::Ref(ref region, mutability) => {
  83                 region.hash_stable(hcx, hasher);
  84                 mutability.hash_stable(hcx, hasher);
  85             }
  86             ty::adjustment::AutoBorrow::RawPtr(mutability) => {
  87                 mutability.hash_stable(hcx, hasher);
  88             }
  89         }
  90     }
  91 }
  92
  93 impl<'a, 'tcx> HashStable<StableHashingContext<'a, 'tcx>> for ty::adjustment::Adjust<'tcx> {
  94     fn hash_stable<W: StableHasherResult>(&self,
  95                                           hcx: &mut StableHashingContext<'a, 'tcx>,
  96                                           hasher: &mut StableHasher<W>) {
  97         mem::discriminant(self).hash_stable(hcx, hasher);
  98         match *self {
  99             ty::adjustment::Adjust::NeverToAny |
 100             ty::adjustment::Adjust::ReifyFnPointer |
 101             ty::adjustment::Adjust::UnsafeFnPointer |
 102             ty::adjustment::Adjust::ClosureFnPointer |
 103             ty::adjustment::Adjust::MutToConstPointer => {}
 104             ty::adjustment::Adjust::DerefRef { autoderefs, ref autoref, unsize } => {
 105                 autoderefs.hash_stable(hcx, hasher);
 106                 autoref.hash_stable(hcx, hasher);
 107                 unsize.hash_stable(hcx, hasher);
 108             }
 109         }
 110     }
 111 }
 112
 113 impl_stable_hash_for!(struct ty::adjustment::Adjustment<'tcx> { kind, target });
 114 impl_stable_hash_for!(struct ty::MethodCall { expr_id, autoderef });
 115 impl_stable_hash_for!(struct ty::MethodCallee<'tcx> { def_id, ty, substs });
 116 impl_stable_hash_for!(struct ty::UpvarId { var_id, closure_expr_id });
 117 impl_stable_hash_for!(struct ty::UpvarBorrow<'tcx> { kind, region });
 118
 119 impl_stable_hash_for!(enum ty::BorrowKind {
 120     ImmBorrow,
 121     UniqueImmBorrow,
 122     MutBorrow
 123 });
 124
 125 impl<'a, 'tcx> HashStable<StableHashingContext<'a, 'tcx>> for ty::UpvarCapture<'tcx> {
 126     fn hash_stable<W: StableHasherResult>(&self,
 127                                           hcx: &mut StableHashingContext<'a, 'tcx>,
 128                                           hasher: &mut StableHasher<W>) {
 129         mem::discriminant(self).hash_stable(hcx, hasher);
 130         match *self {
 131             ty::UpvarCapture::ByValue => {}
 132             ty::UpvarCapture::ByRef(ref up_var_borrow) => {
 133                 up_var_borrow.hash_stable(hcx, hasher);
 134             }
 135         }
 136     }
 137 }
 138
 139 impl_stable_hash_for!(struct ty::FnSig<'tcx> {
 140     inputs_and_output,
 141     variadic,
 142     unsafety,
 143     abi
 144 });
 145
 146 impl<'a, 'tcx, T> HashStable<StableHashingContext<'a, 'tcx>> for ty::Binder<T>
 147     where T: HashStable<StableHashingContext<'a, 'tcx>> + ty::fold::TypeFoldable<'tcx>
 148 {
 149     fn hash_stable<W: StableHasherResult>(&self,
 150                                           hcx: &mut StableHashingContext<'a, 'tcx>,
 151                                           hasher: &mut StableHasher<W>) {
 152         hcx.tcx().anonymize_late_bound_regions(self).0.hash_stable(hcx, hasher);
 153     }
 154 }
 155
 156 impl_stable_hash_for!(enum ty::ClosureKind { Fn, FnMut, FnOnce });
 157
 158 impl_stable_hash_for!(enum ty::Visibility {
 159     Public,
 160     Restricted(def_id),
 161     Invisible
 162 });
 163
 164 impl_stable_hash_for!(struct ty::TraitRef<'tcx> { def_id, substs });
 165 impl_stable_hash_for!(struct ty::TraitPredicate<'tcx> { trait_ref });
 166 impl_stable_hash_for!(tuple_struct ty::EquatePredicate<'tcx> { t1, t2 });
 167 impl_stable_hash_for!(struct ty::SubtypePredicate<'tcx> { a_is_expected, a, b });
 168
 169 impl<'a, 'tcx, A, B> HashStable<StableHashingContext<'a, 'tcx>> for ty::OutlivesPredicate<A, B>
 170     where A: HashStable<StableHashingContext<'a, 'tcx>>,
 171           B: HashStable<StableHashingContext<'a, 'tcx>>,
 172 {
 173     fn hash_stable<W: StableHasherResult>(&self,
 174                                           hcx: &mut StableHashingContext<'a, 'tcx>,
 175                                           hasher: &mut StableHasher<W>) {
 176         let ty::OutlivesPredicate(ref a, ref b) = *self;
 177         a.hash_stable(hcx, hasher);
 178         b.hash_stable(hcx, hasher);
 179     }
 180 }
 181
 182 impl_stable_hash_for!(struct ty::ProjectionPredicate<'tcx> { projection_ty, ty });
 183 impl_stable_hash_for!(struct ty::ProjectionTy<'tcx> { trait_ref, item_name });
 184
 185
 186 impl<'a, 'tcx> HashStable<StableHashingContext<'a, 'tcx>> for ty::Predicate<'tcx> {
 187     fn hash_stable<W: StableHasherResult>(&self,
 188                                           hcx: &mut StableHashingContext<'a, 'tcx>,
 189                                           hasher: &mut StableHasher<W>) {
 190         mem::discriminant(self).hash_stable(hcx, hasher);
 191         match *self {
 192             ty::Predicate::Trait(ref pred) => {
 193                 pred.hash_stable(hcx, hasher);
 194             }
 195             ty::Predicate::Equate(ref pred) => {
 196                 pred.hash_stable(hcx, hasher);
 197             }
 198             ty::Predicate::Subtype(ref pred) => {
 199                 pred.hash_stable(hcx, hasher);
 200             }
 201             ty::Predicate::RegionOutlives(ref pred) => {
 202                 pred.hash_stable(hcx, hasher);
 203             }
 204             ty::Predicate::TypeOutlives(ref pred) => {
 205                 pred.hash_stable(hcx, hasher);
 206             }
 207             ty::Predicate::Projection(ref pred) => {
 208                 pred.hash_stable(hcx, hasher);
 209             }
 210             ty::Predicate::WellFormed(ty) => {
 211                 ty.hash_stable(hcx, hasher);
 212             }
 213             ty::Predicate::ObjectSafe(def_id) => {
 214                 def_id.hash_stable(hcx, hasher);
 215             }
 216             ty::Predicate::ClosureKind(def_id, closure_kind) => {
 217                 def_id.hash_stable(hcx, hasher);
 218                 closure_kind.hash_stable(hcx, hasher);
 219             }
 220         }
 221     }
 222 }
 223
 224 impl<'a, 'tcx> HashStable<StableHashingContext<'a, 'tcx>> for ty::AdtFlags {
 225     fn hash_stable<W: StableHasherResult>(&self,
 226                                           _: &mut StableHashingContext<'a, 'tcx>,
 227                                           hasher: &mut StableHasher<W>) {
 228         std_hash::Hash::hash(self, hasher);
 229     }
 230 }
 231
 232 impl_stable_hash_for!(struct ty::VariantDef {
 233     did,
 234     name,
 235     discr,
 236     fields,
 237     ctor_kind
 238 });
 239
 240 impl_stable_hash_for!(enum ty::VariantDiscr {
 241     Explicit(def_id),
 242     Relative(distance)
 243 });
 244
 245 impl_stable_hash_for!(struct ty::FieldDef {
 246     did,
 247     name,
 248     vis
 249 });
 250
 251 impl<'a, 'tcx> HashStable<StableHashingContext<'a, 'tcx>>
 252 for ::middle::const_val::ConstVal<'tcx> {
 253     fn hash_stable<W: StableHasherResult>(&self,
 254                                           hcx: &mut StableHashingContext<'a, 'tcx>,
 255                                           hasher: &mut StableHasher<W>) {
 256         use middle::const_val::ConstVal;
 257
 258         mem::discriminant(self).hash_stable(hcx, hasher);
 259
 260         match *self {
 261             ConstVal::Float(ref value) => {
 262                 value.hash_stable(hcx, hasher);
 263             }
 264             ConstVal::Integral(ref value) => {
 265                 value.hash_stable(hcx, hasher);
 266             }
 267             ConstVal::Str(ref value) => {
 268                 value.hash_stable(hcx, hasher);
 269             }
 270             ConstVal::ByteStr(ref value) => {
 271                 value.hash_stable(hcx, hasher);
 272             }
 273             ConstVal::Bool(value) => {
 274                 value.hash_stable(hcx, hasher);
 275             }
 276             ConstVal::Char(value) => {
 277                 value.hash_stable(hcx, hasher);
 278             }
 279             ConstVal::Variant(def_id) => {
 280                 def_id.hash_stable(hcx, hasher);
 281             }
 282             ConstVal::Function(def_id, substs) => {
 283                 def_id.hash_stable(hcx, hasher);
 284                 substs.hash_stable(hcx, hasher);
 285             }
 286             ConstVal::Struct(ref name_value_map) => {
 287                 let mut values: Vec<(InternedString, &ConstVal)> =
 288                     name_value_map.iter()
 289                                   .map(|(name, val)| (name.as_str(), val))
 290                                   .collect();
 291
 292                 values.sort_unstable_by_key(|&(ref name, _)| name.clone());
 293                 values.hash_stable(hcx, hasher);
 294             }
 295             ConstVal::Tuple(ref value) => {
 296                 value.hash_stable(hcx, hasher);
 297             }
 298             ConstVal::Array(ref value) => {
 299                 value.hash_stable(hcx, hasher);
 300             }
 301             ConstVal::Repeat(ref value, times) => {
 302                 value.hash_stable(hcx, hasher);
 303                 times.hash_stable(hcx, hasher);
 304             }
 305         }
 306     }
 307 }
 308
 309 impl_stable_hash_for!(struct ty::ClosureSubsts<'tcx> { substs });
 310
 311 impl_stable_hash_for!(struct ty::GenericPredicates<'tcx> {
 312     parent,
 313     predicates
 314 });
 315
 316 impl_stable_hash_for!(enum ty::Variance {
 317     Covariant,
 318     Invariant,
 319     Contravariant,
 320     Bivariant
 321 });
 322
 323 impl_stable_hash_for!(enum ty::adjustment::CustomCoerceUnsized {
 324     Struct(index)
 325 });
 326
 327 impl<'a, 'tcx> HashStable<StableHashingContext<'a, 'tcx>> for ty::Generics {
 328     fn hash_stable<W: StableHasherResult>(&self,
 329                                           hcx: &mut StableHashingContext<'a, 'tcx>,
 330                                           hasher: &mut StableHasher<W>) {
 331         let ty::Generics {
 332             parent,
 333             parent_regions,
 334             parent_types,
 335             ref regions,
 336             ref types,
 337
 338             // Reverse map to each `TypeParameterDef`'s `index` field, from
 339             // `def_id.index` (`def_id.krate` is the same as the item's).
 340             type_param_to_index: _, // Don't hash this
 341             has_self,
 342         } = *self;
 343
 344         parent.hash_stable(hcx, hasher);
 345         parent_regions.hash_stable(hcx, hasher);
 346         parent_types.hash_stable(hcx, hasher);
 347         regions.hash_stable(hcx, hasher);
 348         types.hash_stable(hcx, hasher);
 349         has_self.hash_stable(hcx, hasher);
 350     }
 351 }
 352
 353 impl<'a, 'tcx> HashStable<StableHashingContext<'a, 'tcx>> for ty::RegionParameterDef {
 354     fn hash_stable<W: StableHasherResult>(&self,
 355                                           hcx: &mut StableHashingContext<'a, 'tcx>,
 356                                           hasher: &mut StableHasher<W>) {
 357         let ty::RegionParameterDef {
 358             name,
 359             def_id,
 360             index,
 361             issue_32330: _,
 362             pure_wrt_drop
 363         } = *self;
 364
 365         name.hash_stable(hcx, hasher);
 366         def_id.hash_stable(hcx, hasher);
 367         index.hash_stable(hcx, hasher);
 368         pure_wrt_drop.hash_stable(hcx, hasher);
 369     }
 370 }
 371
 372 impl_stable_hash_for!(struct ty::TypeParameterDef {
 373     name,
 374     def_id,
 375     index,
 376     has_default,
 377     object_lifetime_default,
 378     pure_wrt_drop
 379 });
 380
 381
 382 impl<'a, 'tcx, T> HashStable<StableHashingContext<'a, 'tcx>>
 383 for ::middle::resolve_lifetime::Set1<T>
 384     where T: HashStable<StableHashingContext<'a, 'tcx>>
 385 {
 386     fn hash_stable<W: StableHasherResult>(&self,
 387                                           hcx: &mut StableHashingContext<'a, 'tcx>,
 388                                           hasher: &mut StableHasher<W>) {
 389         use middle::resolve_lifetime::Set1;
 390
 391         mem::discriminant(self).hash_stable(hcx, hasher);
 392         match *self {
 393             Set1::Empty |
 394             Set1::Many => {
 395                 // Nothing to do.
 396             }
 397             Set1::One(ref value) => {
 398                 value.hash_stable(hcx, hasher);
 399             }
 400         }
 401     }
 402 }
 403
 404 impl_stable_hash_for!(enum ::middle::resolve_lifetime::Region {
 405     Static,
 406     EarlyBound(index, decl),
 407     LateBound(db_index, decl),
 408     LateBoundAnon(db_index, anon_index),
 409     Free(call_site_scope_data, decl)
 410 });
 411
 412 impl_stable_hash_for!(struct ::middle::region::CallSiteScopeData {
 413     fn_id,
 414     body_id
 415 });
 416
 417 impl_stable_hash_for!(struct ty::DebruijnIndex {
 418     depth
 419 });
 420
 421 impl_stable_hash_for!(enum ty::cast::CastKind {
 422     CoercionCast,
 423     PtrPtrCast,
 424     PtrAddrCast,
 425     AddrPtrCast,
 426     NumericCast,
 427     EnumCast,
 428     PrimIntCast,
 429     U8CharCast,
 430     ArrayPtrCast,
 431     FnPtrPtrCast,
 432     FnPtrAddrCast
 433 });
 434
 435 impl<'a, 'tcx> HashStable<StableHashingContext<'a, 'tcx>> for ::middle::region::CodeExtentData
 436 {
 437     fn hash_stable<W: StableHasherResult>(&self,
 438                                           hcx: &mut StableHashingContext<'a, 'tcx>,
 439                                           hasher: &mut StableHasher<W>) {
 440         use middle::region::CodeExtentData;
 441
 442         mem::discriminant(self).hash_stable(hcx, hasher);
 443         match *self {
 444             CodeExtentData::Misc(node_id) |
 445             CodeExtentData::DestructionScope(node_id) => {
 446                 node_id.hash_stable(hcx, hasher);
 447             }
 448             CodeExtentData::CallSiteScope { fn_id, body_id } |
 449             CodeExtentData::ParameterScope { fn_id, body_id } => {
 450                 fn_id.hash_stable(hcx, hasher);
 451                 body_id.hash_stable(hcx, hasher);
 452             }
 453             CodeExtentData::Remainder(block_remainder) => {
 454                 block_remainder.hash_stable(hcx, hasher);
 455             }
 456         }
 457     }
 458 }
 459
 460 impl_stable_hash_for!(struct ::middle::region::BlockRemainder {
 461     block,
 462     first_statement_index
 463 });
 464
 465 impl_stable_hash_for!(struct ty::adjustment::CoerceUnsizedInfo {
 466     custom_kind
 467 });
 468
 469 impl_stable_hash_for!(struct ty::FreeRegion<'tcx> {
 470     scope,
 471     bound_region
 472 });
 473
 474 impl_stable_hash_for!(enum ty::BoundRegion {
 475     BrAnon(index),
 476     BrNamed(def_id, name),
 477     BrFresh(index),
 478     BrEnv
 479 });
 480
 481 impl<'a, 'tcx> HashStable<StableHashingContext<'a, 'tcx>> for ty::TypeVariants<'tcx>
 482 {
 483     fn hash_stable<W: StableHasherResult>(&self,
 484                                           hcx: &mut StableHashingContext<'a, 'tcx>,
 485                                           hasher: &mut StableHasher<W>) {
 486         use ty::TypeVariants::*;
 487
 488         mem::discriminant(self).hash_stable(hcx, hasher);
 489         match *self {
 490             TyBool  |
 491             TyChar  |
 492             TyStr   |
 493             TyNever => {
 494                 // Nothing more to hash.
 495             }
 496             TyInt(int_ty) => {
 497                 int_ty.hash_stable(hcx, hasher);
 498             }
 499             TyUint(uint_ty) => {
 500                 uint_ty.hash_stable(hcx, hasher);
 501             }
 502             TyFloat(float_ty)  => {
 503                 float_ty.hash_stable(hcx, hasher);
 504             }
 505             TyAdt(adt_def, substs) => {
 506                 adt_def.hash_stable(hcx, hasher);
 507                 substs.hash_stable(hcx, hasher);
 508             }
 509             TyArray(inner_ty, len) => {
 510                 inner_ty.hash_stable(hcx, hasher);
 511                 len.hash_stable(hcx, hasher);
 512             }
 513             TySlice(inner_ty) => {
 514                 inner_ty.hash_stable(hcx, hasher);
 515             }
 516             TyRawPtr(pointee_ty) => {
 517                 pointee_ty.hash_stable(hcx, hasher);
 518             }
 519             TyRef(region, pointee_ty) => {
 520                 region.hash_stable(hcx, hasher);
 521                 pointee_ty.hash_stable(hcx, hasher);
 522             }
 523             TyFnDef(def_id, substs, ref sig) => {
 524                 def_id.hash_stable(hcx, hasher);
 525                 substs.hash_stable(hcx, hasher);
 526                 sig.hash_stable(hcx, hasher);
 527             }
 528             TyFnPtr(ref sig) => {
 529                 sig.hash_stable(hcx, hasher);
 530             }
 531             TyDynamic(ref existential_predicates, region) => {
 532                 existential_predicates.hash_stable(hcx, hasher);
 533                 region.hash_stable(hcx, hasher);
 534             }
 535             TyClosure(def_id, closure_substs) => {
 536                 def_id.hash_stable(hcx, hasher);
 537                 closure_substs.hash_stable(hcx, hasher);
 538             }
 539             TyTuple(inner_tys, from_diverging_type_var) => {
 540                 inner_tys.hash_stable(hcx, hasher);
 541                 from_diverging_type_var.hash_stable(hcx, hasher);
 542             }
 543             TyProjection(ref projection_ty) => {
 544                 projection_ty.hash_stable(hcx, hasher);
 545             }
 546             TyAnon(def_id, substs) => {
 547                 def_id.hash_stable(hcx, hasher);
 548                 substs.hash_stable(hcx, hasher);
 549             }
 550             TyParam(param_ty) => {
 551                 param_ty.hash_stable(hcx, hasher);
 552             }
 553
 554             TyError     |
 555             TyInfer(..) => {
 556                 bug!("ty::TypeVariants::hash_stable() - Unexpected variant.")
 557             }
 558         }
 559     }
 560 }
 561
 562 impl_stable_hash_for!(struct ty::ParamTy {
 563     idx,
 564     name
 565 });
 566
 567 impl_stable_hash_for!(struct ty::TypeAndMut<'tcx> {
 568     ty,
 569     mutbl
 570 });
 571
 572 impl<'a, 'tcx> HashStable<StableHashingContext<'a, 'tcx>> for ty::ExistentialPredicate<'tcx>
 573 {
 574     fn hash_stable<W: StableHasherResult>(&self,
 575                                           hcx: &mut StableHashingContext<'a, 'tcx>,
 576                                           hasher: &mut StableHasher<W>) {
 577         mem::discriminant(self).hash_stable(hcx, hasher);
 578         match *self {
 579             ty::ExistentialPredicate::Trait(ref trait_ref) => {
 580                 trait_ref.hash_stable(hcx, hasher);
 581             }
 582             ty::ExistentialPredicate::Projection(ref projection) => {
 583                 projection.hash_stable(hcx, hasher);
 584             }
 585             ty::ExistentialPredicate::AutoTrait(def_id) => {
 586                 def_id.hash_stable(hcx, hasher);
 587             }
 588         }
 589     }
 590 }
 591
 592 impl_stable_hash_for!(struct ty::ExistentialTraitRef<'tcx> {
 593     def_id,
 594     substs
 595 });
 596
 597 impl_stable_hash_for!(struct ty::ExistentialProjection<'tcx> {
 598     trait_ref,
 599     item_name,
 600     ty
 601 });
 602
 603
 604 impl<'a, 'tcx> HashStable<StableHashingContext<'a, 'tcx>> for ty::TypeckTables<'tcx> {
 605     fn hash_stable<W: StableHasherResult>(&self,
 606                                           hcx: &mut StableHashingContext<'a, 'tcx>,
 607                                           hasher: &mut StableHasher<W>) {
 608         let ty::TypeckTables {
 609             ref type_relative_path_defs,
 610             ref node_types,
 611             ref item_substs,
 612             ref adjustments,
 613             ref method_map,
 614             ref upvar_capture_map,
 615             ref closure_tys,
 616             ref closure_kinds,
 617             ref liberated_fn_sigs,
 618             ref fru_field_types,
 619
 620             ref cast_kinds,
 621
 622             // FIXME(#41184): This is still ignored at the moment.
 623             lints: _,
 624             ref used_trait_imports,
 625             tainted_by_errors,
 626             ref free_region_map,
 627         } = *self;
 628
 629         hcx.with_node_id_hashing_mode(NodeIdHashingMode::HashDefPath, |hcx| {
 630             ich::hash_stable_nodemap(hcx, hasher, type_relative_path_defs);
 631             ich::hash_stable_nodemap(hcx, hasher, node_types);
 632             ich::hash_stable_nodemap(hcx, hasher, item_substs);
 633             ich::hash_stable_nodemap(hcx, hasher, adjustments);
 634
 635             ich::hash_stable_hashmap(hcx, hasher, method_map, |hcx, method_call| {
 636                 let ty::MethodCall {
 637                     expr_id,
 638                     autoderef
 639                 } = *method_call;
 640
 641                 let def_id = hcx.tcx().hir.local_def_id(expr_id);
 642                 (hcx.def_path_hash(def_id), autoderef)
 643             });
 644
 645             ich::hash_stable_hashmap(hcx, hasher, upvar_capture_map, |hcx, up_var_id| {
 646                 let ty::UpvarId {
 647                     var_id,
 648                     closure_expr_id
 649                 } = *up_var_id;
 650
 651                 let var_def_id = hcx.tcx().hir.local_def_id(var_id);
 652                 let closure_def_id = hcx.tcx().hir.local_def_id(closure_expr_id);
 653                 (hcx.def_path_hash(var_def_id), hcx.def_path_hash(closure_def_id))
 654             });
 655
 656             ich::hash_stable_nodemap(hcx, hasher, closure_tys);
 657             ich::hash_stable_nodemap(hcx, hasher, closure_kinds);
 658             ich::hash_stable_nodemap(hcx, hasher, liberated_fn_sigs);
 659             ich::hash_stable_nodemap(hcx, hasher, fru_field_types);
 660             ich::hash_stable_nodemap(hcx, hasher, cast_kinds);
 661
 662             ich::hash_stable_hashset(hcx, hasher, used_trait_imports, |hcx, def_id| {
 663                 hcx.def_path_hash(*def_id)
 664             });
 665
 666             tainted_by_errors.hash_stable(hcx, hasher);
 667             free_region_map.hash_stable(hcx, hasher);
 668         })
 669     }
 670 }