Lift pure_wrt_drop to GenericParamDef

17 files changed, 40 insertions, 60 deletions

diff --git a/src/librustc/ich/impls_ty.rs b/src/librustc/ich/impls_ty.rs
index e06d22607b7..31dce2a14c2 100644
--- a/src/librustc/ich/impls_ty.rs
+++ b/src/librustc/ich/impls_ty.rs
@@ -754,7 +754,7 @@ impl<'a> HashStable<StableHashingContext<'a>> for ty::Generics {
 }
 
 impl_stable_hash_for!(enum ty::GenericParamDefKind {
-    Lifetime(lt),
+    Lifetime,
     Type(ty)
 });
 
@@ -762,17 +762,13 @@ impl_stable_hash_for!(struct ty::GenericParamDef {
     name,
     def_id,
     index,
+    pure_wrt_drop,
     kind
 });
 
-impl_stable_hash_for!(struct ty::LifetimeParamDef {
-    pure_wrt_drop
-});
-
 impl_stable_hash_for!(struct ty::TypeParamDef {
     has_default,
     object_lifetime_default,
-    pure_wrt_drop,
     synthetic
 });
 
diff --git a/src/librustc/infer/anon_types/mod.rs b/src/librustc/infer/anon_types/mod.rs
index 95727d10b18..d681e2e3d34 100644
--- a/src/librustc/infer/anon_types/mod.rs
+++ b/src/librustc/infer/anon_types/mod.rs
@@ -315,7 +315,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
         let mut least_region = None;
         for param in &abstract_type_generics.params {
             match param.kind {
-                GenericParamDefKind::Lifetime(_) => {}
+                GenericParamDefKind::Lifetime => {}
                 _ => continue
             }
             // Get the value supplied for this region from the substs.
diff --git a/src/librustc/middle/resolve_lifetime.rs b/src/librustc/middle/resolve_lifetime.rs
index bed5ee91800..900fbdfdead 100644
--- a/src/librustc/middle/resolve_lifetime.rs
+++ b/src/librustc/middle/resolve_lifetime.rs
@@ -1666,7 +1666,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
                                     GenericParamDefKind::Type(ty) => {
                                         Some(ty.object_lifetime_default)
                                     }
-                                    GenericParamDefKind::Lifetime(_) => None,
+                                    GenericParamDefKind::Lifetime => None,
                                 }
                             })
                             .collect()
diff --git a/src/librustc/traits/auto_trait.rs b/src/librustc/traits/auto_trait.rs
index 4bb5387efb3..227cba40d14 100644
--- a/src/librustc/traits/auto_trait.rs
+++ b/src/librustc/traits/auto_trait.rs
@@ -226,7 +226,7 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> {
                 .iter()
                 .filter_map(|param| {
                     match param.kind {
-                        ty::GenericParamDefKind::Lifetime(_) => Some(param.name.to_string()),
+                        ty::GenericParamDefKind::Lifetime => Some(param.name.to_string()),
                         _ => None
                     }
                 })
diff --git a/src/librustc/traits/error_reporting.rs b/src/librustc/traits/error_reporting.rs
index 9d71fe6f2d7..f56720328b2 100644
--- a/src/librustc/traits/error_reporting.rs
+++ b/src/librustc/traits/error_reporting.rs
@@ -386,7 +386,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
                     let ty = trait_ref.substs.type_for_def(&param);
                     ty.to_string()
                 },
-                GenericParamDefKind::Lifetime(_) => continue,
+                GenericParamDefKind::Lifetime => continue,
             };
             flags.push((name.clone(), Some(value.clone())));
         }
diff --git a/src/librustc/traits/on_unimplemented.rs b/src/librustc/traits/on_unimplemented.rs
index 1980fbbe3ed..ff10c430f7b 100644
--- a/src/librustc/traits/on_unimplemented.rs
+++ b/src/librustc/traits/on_unimplemented.rs
@@ -293,7 +293,7 @@ impl<'a, 'gcx, 'tcx> OnUnimplementedFormatString {
                     Some((param.name.to_string(),
                          trait_ref.substs.type_for_def(&param).to_string()))
                 },
-                GenericParamDefKind::Lifetime(_) => None
+                GenericParamDefKind::Lifetime => None
             }
         }).collect::<FxHashMap<String, String>>();
 
diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs
index c3e9ffec9a0..42aed9940ad 100644
--- a/src/librustc/ty/mod.rs
+++ b/src/librustc/ty/mod.rs
@@ -713,23 +713,9 @@ pub struct FloatVarValue(pub ast::FloatTy);
 pub struct TypeParamDef {
     pub has_default: bool,
     pub object_lifetime_default: ObjectLifetimeDefault,
-
-    /// `pure_wrt_drop`, set by the (unsafe) `#[may_dangle]` attribute
-    /// on generic parameter `T`, asserts data behind the parameter
-    /// `T` won't be accessed during the parent type's `Drop` impl.
-    pub pure_wrt_drop: bool,
-
     pub synthetic: Option<hir::SyntheticTyParamKind>,
 }
 
-#[derive(Copy, Clone, Debug, RustcEncodable, RustcDecodable)]
-pub struct LifetimeParamDef {
-    /// `pure_wrt_drop`, set by the (unsafe) `#[may_dangle]` attribute
-    /// on generic parameter `'a`, asserts data of lifetime `'a`
-    /// won't be accessed during the parent type's `Drop` impl.
-    pub pure_wrt_drop: bool,
-}
-
 impl ty::EarlyBoundRegion {
     pub fn to_bound_region(&self) -> ty::BoundRegion {
         ty::BoundRegion::BrNamed(self.def_id, self.name)
@@ -738,7 +724,7 @@ impl ty::EarlyBoundRegion {
 
 #[derive(Clone, Debug, RustcEncodable, RustcDecodable)]
 pub enum GenericParamDefKind {
-    Lifetime(LifetimeParamDef),
+    Lifetime,
     Type(TypeParamDef),
 }
 
@@ -747,17 +733,16 @@ pub struct GenericParamDef {
     pub name: InternedString,
     pub def_id: DefId,
     pub index: u32,
+
+    /// `pure_wrt_drop`, set by the (unsafe) `#[may_dangle]` attribute
+    /// on generic parameter `'a`/`T`, asserts data behind the parameter
+    /// `'a`/`T` won't be accessed during the parent type's `Drop` impl.
+    pub pure_wrt_drop: bool,
+
     pub kind: GenericParamDefKind,
 }
 
 impl GenericParamDef {
-    pub fn to_lifetime(&self) -> LifetimeParamDef {
-        match self.kind {
-            GenericParamDefKind::Lifetime(lt) => lt,
-            _ => bug!("cannot convert a non-lifetime to a lifetime")
-        }
-    }
-
     pub fn to_type(&self) -> TypeParamDef {
         match self.kind {
             GenericParamDefKind::Type(ty) => ty,
@@ -767,7 +752,7 @@ impl GenericParamDef {
 
     pub fn to_early_bound_region_data(&self) -> ty::EarlyBoundRegion {
         match self.kind {
-            GenericParamDefKind::Lifetime(_) => {
+            GenericParamDefKind::Lifetime => {
                 ty::EarlyBoundRegion {
                     def_id: self.def_id,
                     index: self.index,
@@ -780,7 +765,7 @@ impl GenericParamDef {
 
     pub fn to_bound_region(&self) -> ty::BoundRegion {
         match self.kind {
-            GenericParamDefKind::Lifetime(_) => {
+            GenericParamDefKind::Lifetime => {
                 self.to_early_bound_region_data().to_bound_region()
             }
             _ => bug!("cannot convert a non-lifetime parameter def to an early bound region")
@@ -827,7 +812,7 @@ impl<'a, 'gcx, 'tcx> Generics {
 
         for param in self.params.iter() {
             match param.kind {
-                GenericParamDefKind::Lifetime(_) => param_counts.lifetimes += 1,
+                GenericParamDefKind::Lifetime => param_counts.lifetimes += 1,
                 GenericParamDefKind::Type(_) => param_counts.types += 1,
             };
         }
@@ -839,7 +824,7 @@ impl<'a, 'gcx, 'tcx> Generics {
         for param in self.params.iter() {
             match param.kind {
                 GenericParamDefKind::Type(_) => return true,
-                GenericParamDefKind::Lifetime(_) => {}
+                GenericParamDefKind::Lifetime => {}
             }
         }
         if let Some(parent_def_id) = self.parent {
@@ -858,7 +843,7 @@ impl<'a, 'gcx, 'tcx> Generics {
         if let Some(index) = param.index.checked_sub(self.parent_count as u32) {
             let param = &self.params[index as usize];
             match param.kind {
-                ty::GenericParamDefKind::Lifetime(_) => param,
+                ty::GenericParamDefKind::Lifetime => param,
                 _ => bug!("expected region parameter, but found another generic parameter")
             }
         } else {
diff --git a/src/librustc/ty/subst.rs b/src/librustc/ty/subst.rs
index a14045b43f2..d4db2ae481a 100644
--- a/src/librustc/ty/subst.rs
+++ b/src/librustc/ty/subst.rs
@@ -243,7 +243,7 @@ impl<'a, 'gcx, 'tcx> Substs<'tcx> {
           FT: FnMut(&ty::GenericParamDef, &[Kind<'tcx>]) -> Ty<'tcx> {
         for param in &defs.params {
             let kind = match param.kind {
-                ty::GenericParamDefKind::Lifetime(_) => mk_region(param, substs).into(),
+                ty::GenericParamDefKind::Lifetime => mk_region(param, substs).into(),
                 ty::GenericParamDefKind::Type(_) => mk_type(param, substs).into(),
             };
             assert_eq!(param.index as usize, substs.len());
diff --git a/src/librustc/ty/util.rs b/src/librustc/ty/util.rs
index db11f465972..fdd0754730f 100644
--- a/src/librustc/ty/util.rs
+++ b/src/librustc/ty/util.rs
@@ -505,12 +505,12 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
             .filter(|&(_, &k)| {
                 match k.unpack() {
                     UnpackedKind::Lifetime(&ty::RegionKind::ReEarlyBound(ref ebr)) => {
-                        !impl_generics.region_param(ebr, self).to_lifetime().pure_wrt_drop
+                        !impl_generics.region_param(ebr, self).pure_wrt_drop
                     }
                     UnpackedKind::Type(&ty::TyS {
                         sty: ty::TypeVariants::TyParam(ref pt), ..
                     }) => {
-                        !impl_generics.type_param(pt, self).to_type().pure_wrt_drop
+                        !impl_generics.type_param(pt, self).pure_wrt_drop
                     }
                     UnpackedKind::Lifetime(_) | UnpackedKind::Type(_) => {
                         // not a type or region param - this should be reported
diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs
index ca939b161d2..b3e840ae025 100644
--- a/src/librustc/util/ppaux.rs
+++ b/src/librustc/util/ppaux.rs
@@ -340,7 +340,7 @@ impl PrintContext {
                     generics.params.iter().rev().filter_map(|param| {
                         match param.kind {
                             GenericParamDefKind::Type(ty) => Some((param.def_id, ty.has_default)),
-                            GenericParamDefKind::Lifetime(_) => None,
+                            GenericParamDefKind::Lifetime => None,
                         }
                     });
                 if let Some(last_ty) = type_params.next() {
@@ -606,7 +606,7 @@ define_print! {
 impl fmt::Debug for ty::GenericParamDef {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let type_name = match self.kind {
-            ty::GenericParamDefKind::Lifetime(_) => "Lifetime",
+            ty::GenericParamDefKind::Lifetime => "Lifetime",
             ty::GenericParamDefKind::Type(_) => "Type",
         };
         write!(f, "{}({}, {:?}, {})",
diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs
index 929030e832e..6e9b03cd2a9 100644
--- a/src/librustc_privacy/lib.rs
+++ b/src/librustc_privacy/lib.rs
@@ -406,7 +406,7 @@ impl<'b, 'a, 'tcx> ReachEverythingInTheInterfaceVisitor<'b, 'a, 'tcx> {
                         self.ev.tcx.type_of(param.def_id).visit_with(self);
                     }
                 }
-                GenericParamDefKind::Lifetime(_) => {}
+                GenericParamDefKind::Lifetime => {}
             }
         }
         self
@@ -1347,7 +1347,7 @@ impl<'a, 'tcx: 'a> SearchInterfaceForPrivateItemsVisitor<'a, 'tcx> {
                         self.tcx.type_of(param.def_id).visit_with(self);
                     }
                 }
-                GenericParamDefKind::Lifetime(_) => {}
+                GenericParamDefKind::Lifetime => {}
             }
         }
         self
diff --git a/src/librustc_typeck/check/compare_method.rs b/src/librustc_typeck/check/compare_method.rs
index 11f421da714..86913fcadfa 100644
--- a/src/librustc_typeck/check/compare_method.rs
+++ b/src/librustc_typeck/check/compare_method.rs
@@ -731,13 +731,13 @@ fn compare_synthetic_generics<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
     let impl_m_type_params = impl_m_generics.params.iter().filter_map(|param| {
         match param.kind {
             GenericParamDefKind::Type(_) => Some(param),
-            GenericParamDefKind::Lifetime(_) => None,
+            GenericParamDefKind::Lifetime => None,
         }
     });
     let trait_m_type_params = trait_m_generics.params.iter().filter_map(|param| {
         match param.kind {
             GenericParamDefKind::Type(_) => Some(param),
-            GenericParamDefKind::Lifetime(_) => None,
+            GenericParamDefKind::Lifetime => None,
         }
     });
     for (impl_ty, trait_ty) in impl_m_type_params.zip(trait_m_type_params) {
diff --git a/src/librustc_typeck/check/wfcheck.rs b/src/librustc_typeck/check/wfcheck.rs
index 740a3dfcac9..a96652f953e 100644
--- a/src/librustc_typeck/check/wfcheck.rs
+++ b/src/librustc_typeck/check/wfcheck.rs
@@ -652,7 +652,7 @@ fn reject_shadowing_parameters(tcx: TyCtxt, def_id: DefId) {
         parent.params.iter()
                      .flat_map(|param| {
                          match param.kind {
-                             GenericParamDefKind::Lifetime(_) => None,
+                             GenericParamDefKind::Lifetime => None,
                              GenericParamDefKind::Type(_) => Some((param.name, param.def_id)),
                          }
                      })
@@ -661,7 +661,7 @@ fn reject_shadowing_parameters(tcx: TyCtxt, def_id: DefId) {
     for method_param in generics.params.iter() {
         match method_param.kind {
             // Shadowing is checked in resolve_lifetime.
-            GenericParamDefKind::Lifetime(_) => continue,
+            GenericParamDefKind::Lifetime => continue,
             _ => {},
         };
         if impl_params.contains_key(&method_param.name) {
diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs
index 3be702189fb..1cc2730158f 100644
--- a/src/librustc_typeck/collect.rs
+++ b/src/librustc_typeck/collect.rs
@@ -844,10 +844,10 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                         index: 0,
                         name: keywords::SelfType.name().as_interned_str(),
                         def_id: tcx.hir.local_def_id(param_id),
+                        pure_wrt_drop: false,
                         kind: ty::GenericParamDefKind::Type(ty::TypeParamDef {
                             has_default: false,
                             object_lifetime_default: rl::Set1::Empty,
-                            pure_wrt_drop: false,
                             synthetic: None,
                         }),
                     });
@@ -892,9 +892,8 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
             name: l.lifetime.name.name().as_interned_str(),
             index: own_start + i as u32,
             def_id: tcx.hir.local_def_id(l.lifetime.id),
-            kind: ty::GenericParamDefKind::Lifetime(ty::LifetimeParamDef {
-                pure_wrt_drop: l.pure_wrt_drop,
-            }),
+            pure_wrt_drop: l.pure_wrt_drop,
+            kind: ty::GenericParamDefKind::Lifetime,
         }
     }).collect::<Vec<_>>();
 
@@ -923,11 +922,11 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
             index: type_start + i as u32,
             name: p.name.as_interned_str(),
             def_id: tcx.hir.local_def_id(p.id),
+            pure_wrt_drop: p.pure_wrt_drop,
             kind: ty::GenericParamDefKind::Type(ty::TypeParamDef {
                 has_default: p.default.is_some(),
                 object_lifetime_default:
                     object_lifetime_defaults.as_ref().map_or(rl::Set1::Empty, |o| o[i]),
-                pure_wrt_drop: p.pure_wrt_drop,
                 synthetic: p.synthetic,
             }),
         }
@@ -948,10 +947,10 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                 index: type_start + i as u32,
                 name: Symbol::intern(arg).as_interned_str(),
                 def_id,
+                pure_wrt_drop: false,
                 kind: ty::GenericParamDefKind::Type(ty::TypeParamDef {
                     has_default: false,
                     object_lifetime_default: rl::Set1::Empty,
-                    pure_wrt_drop: false,
                     synthetic: None,
                 }),
             });
@@ -963,10 +962,10 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                     index: type_start + i,
                     name: Symbol::intern("<upvar>").as_interned_str(),
                     def_id,
+                    pure_wrt_drop: false,
                     kind: ty::GenericParamDefKind::Type(ty::TypeParamDef {
                         has_default: false,
                         object_lifetime_default: rl::Set1::Empty,
-                        pure_wrt_drop: false,
                         synthetic: None,
                     }),
                 }
diff --git a/src/librustc_typeck/impl_wf_check.rs b/src/librustc_typeck/impl_wf_check.rs
index f3645142e4b..ef699b201a5 100644
--- a/src/librustc_typeck/impl_wf_check.rs
+++ b/src/librustc_typeck/impl_wf_check.rs
@@ -125,7 +125,7 @@ fn enforce_impl_params_are_constrained<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                     report_unused_parameter(tcx, hir_ty.span, "type", &param_ty.to_string());
                 }
             }
-            (&ty::GenericParamDefKind::Lifetime(_), hir::GenericParam::Lifetime(hir_lt)) => {
+            (&ty::GenericParamDefKind::Lifetime, hir::GenericParam::Lifetime(hir_lt)) => {
                 let param = ctp::Parameter::from(ty_param.to_early_bound_region_data());
                 if lifetimes_in_associated_types.contains(&param) && // (*)
                     !input_parameters.contains(&param) {
@@ -134,7 +134,7 @@ fn enforce_impl_params_are_constrained<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                 }
             }
             (&ty::GenericParamDefKind::Type(_), _) => continue,
-            (&ty::GenericParamDefKind::Lifetime(_), _) => continue,
+            (&ty::GenericParamDefKind::Lifetime, _) => continue,
         }
     }
 
diff --git a/src/librustdoc/clean/auto_trait.rs b/src/librustdoc/clean/auto_trait.rs
index 88784aab90e..d7646ce7bfc 100644
--- a/src/librustdoc/clean/auto_trait.rs
+++ b/src/librustdoc/clean/auto_trait.rs
@@ -229,7 +229,7 @@ impl<'a, 'tcx, 'rcx> AutoTraitFinder<'a, 'tcx, 'rcx> {
 
         for param in generics.params.iter() {
             match param.kind {
-                ty::GenericParamDefKind::Lifetime(_) => {
+                ty::GenericParamDefKind::Lifetime => {
                     let name = if param.name == "" {
                         hir::LifetimeName::Static
                     } else {
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index 69999eb69b0..621ec641ee0 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -1855,7 +1855,7 @@ impl<'a, 'tcx> Clean<Generics> for (&'a ty::Generics,
             params: gens.params
                         .iter()
                         .flat_map(|param| {
-                            if let ty::GenericParamDefKind::Lifetime(_) = param.kind {
+                            if let ty::GenericParamDefKind::Lifetime = param.kind {
                                 Some(GenericParamDef::Lifetime(param.clean(cx)))
                             } else {
                                 None