rustc: move TypeParamDef's fields into GenericParamDefKind::Type.

diff --git a/src/librustc/ich/impls_ty.rs b/src/librustc/ich/impls_ty.rs
index 1b16d93ef274863c0eddb0ba9db8524d6d14a0d9..edd9f0fab519ddd4b201ee61ceeae866372e6695 100644 (file)
--- a/src/librustc/ich/impls_ty.rs
+++ b/src/librustc/ich/impls_ty.rs
@@ -739,8 +739,7 @@ fn hash_stable<W: StableHasherResult>(&self,
             ref parent_count,
             ref params,
 
-            // Reverse map to each `TypeParamDef`'s `index` field, from
-            // `def_id.index` (`def_id.krate` is the same as the item's).
+            // 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,
@@ -754,11 +753,6 @@ fn hash_stable<W: StableHasherResult>(&self,
     }
 }
 
-impl_stable_hash_for!(enum ty::GenericParamDefKind {
-    Lifetime,
-    Type(ty)
-});
-
 impl_stable_hash_for!(struct ty::GenericParamDef {
     name,
     def_id,
@@ -767,11 +761,25 @@ fn hash_stable<W: StableHasherResult>(&self,
     kind
 });
 
-impl_stable_hash_for!(struct ty::TypeParamDef {
-    has_default,
-    object_lifetime_default,
-    synthetic
-});
+impl<'a> HashStable<StableHashingContext<'a>> for ty::GenericParamDefKind {
+    fn hash_stable<W: StableHasherResult>(&self,
+                                          hcx: &mut StableHashingContext<'a>,
+                                          hasher: &mut StableHasher<W>) {
+        mem::discriminant(self).hash_stable(hcx, hasher);
+        match *self {
+            ty::GenericParamDefKind::Lifetime => {}
+            ty::GenericParamDefKind::Type {
+                has_default,
+                ref object_lifetime_default,
+                ref synthetic,
+            } => {
+                has_default.hash_stable(hcx, hasher);
+                object_lifetime_default.hash_stable(hcx, hasher);
+                synthetic.hash_stable(hcx, hasher);
+            }
+        }
+    }
+}
 
 impl<'a, 'gcx, T> HashStable<StableHashingContext<'a>>
 for ::middle::resolve_lifetime::Set1<T>

diff --git a/src/librustc/infer/mod.rs b/src/librustc/infer/mod.rs
index f105ecf7ee4f8c63aea365128d5ea250adeae313..6b31f869ef9b30796ceb1c091d9406326614e73f 100644 (file)
--- a/src/librustc/infer/mod.rs
+++ b/src/librustc/infer/mod.rs
@@ -915,7 +915,7 @@ pub fn var_for_def(&self,
                 // region parameter definition.
                 self.next_region_var(EarlyBoundRegion(span, param.name)).into()
             }
-            GenericParamDefKind::Type(_) => {
+            GenericParamDefKind::Type {..} => {
                 // Create a type inference variable for the given
                 // type parameter definition. The substitutions are
                 // for actual parameters that may be referred to by

diff --git a/src/librustc/middle/resolve_lifetime.rs b/src/librustc/middle/resolve_lifetime.rs
index 900fbdfdeadb3c58af9193f68128f55125d475d6..5f150ba1e2d6f805f0a4b703efce9ec1fc875f02 100644 (file)
--- a/src/librustc/middle/resolve_lifetime.rs
+++ b/src/librustc/middle/resolve_lifetime.rs
@@ -1658,18 +1658,14 @@ fn visit_segment_parameters(
                 self.xcrate_object_lifetime_defaults
                     .entry(def_id)
                     .or_insert_with(|| {
-                        tcx.generics_of(def_id)
-                            .params
-                            .iter()
-                            .filter_map(|param| {
-                                match param.kind {
-                                    GenericParamDefKind::Type(ty) => {
-                                        Some(ty.object_lifetime_default)
-                                    }
-                                    GenericParamDefKind::Lifetime => None,
+                        tcx.generics_of(def_id).params.iter().filter_map(|param| {
+                            match param.kind {
+                                GenericParamDefKind::Type { object_lifetime_default, .. } => {
+                                    Some(object_lifetime_default)
                                 }
-                            })
-                            .collect()
+                                GenericParamDefKind::Lifetime => None,
+                            }
+                        }).collect()
                     })
             };
             unsubst

diff --git a/src/librustc/traits/error_reporting.rs b/src/librustc/traits/error_reporting.rs
index 9ad98b45e96aa81b05cbcb531900e0d993ac341c..49aee8bcd01fe1e916a3bd011e0cb1519ac7e994 100644 (file)
--- a/src/librustc/traits/error_reporting.rs
+++ b/src/librustc/traits/error_reporting.rs
@@ -383,7 +383,7 @@ fn on_unimplemented_note(
 
         for param in generics.params.iter() {
             let value = match param.kind {
-                GenericParamDefKind::Type(_) => {
+                GenericParamDefKind::Type {..} => {
                     trait_ref.substs[param.index as usize].to_string()
                 },
                 GenericParamDefKind::Lifetime => continue,

diff --git a/src/librustc/traits/mod.rs b/src/librustc/traits/mod.rs
index b5115eab7dc34dbdaa3f16a6e0d6663b9cc6fc4f..d846b23d20da772ac6a029b565b26d85825caaee 100644 (file)
--- a/src/librustc/traits/mod.rs
+++ b/src/librustc/traits/mod.rs
@@ -838,7 +838,7 @@ fn vtable_methods<'a, 'tcx>(
                     Substs::for_item(tcx, def_id, |param, _| {
                         match param.kind {
                             GenericParamDefKind::Lifetime => tcx.types.re_erased.into(),
-                            GenericParamDefKind::Type(_) => {
+                            GenericParamDefKind::Type {..} => {
                                 trait_ref.substs[param.index as usize]
                             }
                         }

diff --git a/src/librustc/traits/on_unimplemented.rs b/src/librustc/traits/on_unimplemented.rs
index 539f40cf3efb5a061440bfc4c419a0837bffd5ab..0550cf7c6d2c040a561b6580e9e6a7dd2e9eeb80 100644 (file)
--- a/src/librustc/traits/on_unimplemented.rs
+++ b/src/librustc/traits/on_unimplemented.rs
@@ -289,7 +289,7 @@ pub fn format(&self,
         let generics = tcx.generics_of(trait_ref.def_id);
         let generic_map = generics.params.iter().filter_map(|param| {
             let value = match param.kind {
-                GenericParamDefKind::Type(_) => {
+                GenericParamDefKind::Type {..} => {
                     trait_ref.substs[param.index as usize].to_string()
                 },
                 GenericParamDefKind::Lifetime => return None

diff --git a/src/librustc/ty/context.rs b/src/librustc/ty/context.rs
index 32c693812d67cb019d9b61a7e89ff133ba2c26d0..a3d380c3e146f90f8029281f112ec848acdaa4af 100644 (file)
--- a/src/librustc/ty/context.rs
+++ b/src/librustc/ty/context.rs
@@ -2329,11 +2329,11 @@ pub fn mk_box(self, ty: Ty<'tcx>) -> Ty<'tcx> {
         let substs = Substs::for_item(self, def_id, |param, substs| {
             match param.kind {
                 GenericParamDefKind::Lifetime => bug!(),
-                GenericParamDefKind::Type(ty_param) => {
+                GenericParamDefKind::Type { has_default, .. } => {
                     if param.index == 0 {
                         ty.into()
                     } else {
-                        assert!(ty_param.has_default);
+                        assert!(has_default);
                         self.type_of(param.def_id).subst(self, substs).into()
                     }
                 }
@@ -2477,7 +2477,7 @@ pub fn mk_param_from_def(self, param: &ty::GenericParamDef) -> Kind<'tcx> {
             GenericParamDefKind::Lifetime => {
                 self.mk_region(ty::ReEarlyBound(param.to_early_bound_region_data())).into()
             }
-            GenericParamDefKind::Type(_) => self.mk_ty_param(param.index, param.name).into(),
+            GenericParamDefKind::Type {..} => self.mk_ty_param(param.index, param.name).into(),
         }
     }
 

diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs
index f4f8bb68b3b65e0051fffcde4b87e3d0093a10c7..1726ed27d14d6f49b356816e918cc5a0a0de4aa0 100644 (file)
--- a/src/librustc/ty/mod.rs
+++ b/src/librustc/ty/mod.rs
@@ -714,13 +714,6 @@ pub enum IntVarValue {
 #[derive(Clone, Copy, PartialEq, Eq)]
 pub struct FloatVarValue(pub ast::FloatTy);
 
-#[derive(Copy, Clone, Debug, RustcEncodable, RustcDecodable)]
-pub struct TypeParamDef {
-    pub has_default: bool,
-    pub object_lifetime_default: ObjectLifetimeDefault,
-    pub synthetic: Option<hir::SyntheticTyParamKind>,
-}
-
 impl ty::EarlyBoundRegion {
     pub fn to_bound_region(&self) -> ty::BoundRegion {
         ty::BoundRegion::BrNamed(self.def_id, self.name)
@@ -730,7 +723,11 @@ pub fn to_bound_region(&self) -> ty::BoundRegion {
 #[derive(Clone, Debug, RustcEncodable, RustcDecodable)]
 pub enum GenericParamDefKind {
     Lifetime,
-    Type(TypeParamDef),
+    Type {
+        has_default: bool,
+        object_lifetime_default: ObjectLifetimeDefault,
+        synthetic: Option<hir::SyntheticTyParamKind>,
+    }
 }
 
 #[derive(Clone, RustcEncodable, RustcDecodable)]
@@ -811,7 +808,7 @@ pub fn own_counts(&self) -> GenericParamCount {
         for param in &self.params {
             match param.kind {
                 GenericParamDefKind::Lifetime => own_counts.lifetimes += 1,
-                GenericParamDefKind::Type(_) => own_counts.types += 1,
+                GenericParamDefKind::Type {..} => own_counts.types += 1,
             };
         }
 
@@ -821,7 +818,7 @@ pub fn own_counts(&self) -> GenericParamCount {
     pub fn requires_monomorphization(&self, tcx: TyCtxt<'a, 'gcx, 'tcx>) -> bool {
         for param in &self.params {
             match param.kind {
-                GenericParamDefKind::Type(_) => return true,
+                GenericParamDefKind::Type {..} => return true,
                 GenericParamDefKind::Lifetime => {}
             }
         }
@@ -850,7 +847,7 @@ pub fn region_param(&'tcx self,
         }
     }
 
-    /// Returns the `TypeParamDef` associated with this `ParamTy`.
+    /// Returns the `GenericParamDef` associated with this `ParamTy`.
     pub fn type_param(&'tcx self,
                       param: &ParamTy,
                       tcx: TyCtxt<'a, 'gcx, 'tcx>)
@@ -858,7 +855,7 @@ pub fn type_param(&'tcx self,
         if let Some(index) = param.idx.checked_sub(self.parent_count as u32) {
             let param = &self.params[index as usize];
             match param.kind {
-                ty::GenericParamDefKind::Type(_) => param,
+                ty::GenericParamDefKind::Type {..} => param,
                 _ => bug!("expected type parameter, but found another generic parameter")
             }
         } else {

diff --git a/src/librustc/ty/util.rs b/src/librustc/ty/util.rs
index 7cfcbcb86af98a62ba67d17dbdbd92bfe0d4a1fc..e3db4972edc78ab0f4764b568d05653a54f3d1b3 100644 (file)
--- a/src/librustc/ty/util.rs
+++ b/src/librustc/ty/util.rs
@@ -572,7 +572,7 @@ pub fn empty_substs_for_def_id(self, item_def_id: DefId) -> &'tcx Substs<'tcx> {
         Substs::for_item(self, item_def_id, |param, _| {
             match param.kind {
                 GenericParamDefKind::Lifetime => self.types.re_erased.into(),
-                GenericParamDefKind::Type(_) => {
+                GenericParamDefKind::Type {..} => {
                     bug!("empty_substs_for_def_id: {:?} has type parameters", item_def_id)
                 }
             }

diff --git a/src/librustc/util/ppaux.rs b/src/librustc/util/ppaux.rs
index b8345b6c2d9a347eee56b06d2dedb7958bdbb9ff..82afce415a76124a5a87a7543446da9c5f17c998 100644 (file)
--- a/src/librustc/util/ppaux.rs
+++ b/src/librustc/util/ppaux.rs
@@ -337,7 +337,9 @@ fn parameterized<F: fmt::Write>(&mut self,
                 let mut type_params =
                     generics.params.iter().rev().filter_map(|param| {
                         match param.kind {
-                            GenericParamDefKind::Type(ty) => Some((param.def_id, ty.has_default)),
+                            GenericParamDefKind::Type { has_default, .. } => {
+                                Some((param.def_id, has_default))
+                            }
                             GenericParamDefKind::Lifetime => None,
                         }
                     }).peekable();
@@ -604,7 +606,7 @@ 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::Type(_) => "Type",
+            ty::GenericParamDefKind::Type {..} => "Type",
         };
         write!(f, "{}({}, {:?}, {})",
                type_name,

diff --git a/src/librustc_mir/monomorphize/collector.rs b/src/librustc_mir/monomorphize/collector.rs
index 45429ea7aeaee0e2f051ea64185b92fd5f744084..148b12cdc31247ccf821be0f3e75153261bf0651 100644 (file)
--- a/src/librustc_mir/monomorphize/collector.rs
+++ b/src/librustc_mir/monomorphize/collector.rs
@@ -1115,7 +1115,7 @@ fn create_mono_items_for_default_impls<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                     let substs = Substs::for_item(tcx, method.def_id, |param, _| {
                         match param.kind {
                             GenericParamDefKind::Lifetime => tcx.types.re_erased.into(),
-                            GenericParamDefKind::Type(_) => {
+                            GenericParamDefKind::Type {..} => {
                                 trait_ref.substs[param.index as usize]
                             }
                         }

diff --git a/src/librustc_mir/shim.rs b/src/librustc_mir/shim.rs
index fa4d1fa209eba5b742cfab06b5cde270c2bd1d27..8375a5fb334072c0758cadff419ea285b9727319 100644 (file)
--- a/src/librustc_mir/shim.rs
+++ b/src/librustc_mir/shim.rs
@@ -430,7 +430,7 @@ fn make_clone_call(
         let substs = Substs::for_item(tcx, self.def_id, |param, _| {
             match param.kind {
                 GenericParamDefKind::Lifetime => tcx.types.re_erased.into(),
-                GenericParamDefKind::Type(_) => ty.into(),
+                GenericParamDefKind::Type {..} => ty.into(),
             }
         });
 

diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs
index 6e9b03cd2a9c6cedb35d803f4c1fa0d421f6c6d2..2e887e3d8f097b430bb160a9da6231d2ac376dc1 100644 (file)
--- a/src/librustc_privacy/lib.rs
+++ b/src/librustc_privacy/lib.rs
@@ -401,8 +401,8 @@ impl<'b, 'a, 'tcx> ReachEverythingInTheInterfaceVisitor<'b, 'a, 'tcx> {
     fn generics(&mut self) -> &mut Self {
         for param in &self.ev.tcx.generics_of(self.item_def_id).params {
             match param.kind {
-                GenericParamDefKind::Type(ty) => {
-                    if ty.has_default {
+                GenericParamDefKind::Type { has_default, .. } => {
+                    if has_default {
                         self.ev.tcx.type_of(param.def_id).visit_with(self);
                     }
                 }
@@ -1342,8 +1342,8 @@ impl<'a, 'tcx: 'a> SearchInterfaceForPrivateItemsVisitor<'a, 'tcx> {
     fn generics(&mut self) -> &mut Self {
         for param in &self.tcx.generics_of(self.item_def_id).params {
             match param.kind {
-                GenericParamDefKind::Type(ty) => {
-                    if ty.has_default {
+                GenericParamDefKind::Type { has_default, .. } => {
+                    if has_default {
                         self.tcx.type_of(param.def_id).visit_with(self);
                     }
                 }

diff --git a/src/librustc_typeck/astconv.rs b/src/librustc_typeck/astconv.rs
index c89fe8ff5b67ab86da4101d8e07d0b7801cd591a..f2fe8b1d891d9f6d43188a2b97357d5ec014eb42 100644 (file)
--- a/src/librustc_typeck/astconv.rs
+++ b/src/librustc_typeck/astconv.rs
@@ -224,9 +224,9 @@ fn create_substs_for_ast_path(&self,
                 GenericParamDefKind::Lifetime => {
                     lt_accepted += 1;
                 }
-                GenericParamDefKind::Type(ty) => {
+                GenericParamDefKind::Type { has_default, .. } => {
                     ty_params.accepted += 1;
-                    if !ty.has_default {
+                    if !has_default {
                         ty_params.required += 1;
                     }
                 }
@@ -251,8 +251,8 @@ fn create_substs_for_ast_path(&self,
 
         let is_object = self_ty.map_or(false, |ty| ty.sty == TRAIT_OBJECT_DUMMY_SELF);
         let default_needs_object_self = |param: &ty::GenericParamDef| {
-            if let GenericParamDefKind::Type(ty) = param.kind {
-                if is_object && ty.has_default {
+            if let GenericParamDefKind::Type { has_default, .. } = param.kind {
+                if is_object && has_default {
                     if tcx.at(span).type_of(param.def_id).has_self_ty() {
                         // There is no suitable inference default for a type parameter
                         // that references self, in an object type.
@@ -275,7 +275,7 @@ fn create_substs_for_ast_path(&self,
                         tcx.types.re_static.into()
                     }
                 }
-                GenericParamDefKind::Type(ty) => {
+                GenericParamDefKind::Type { has_default, .. } => {
                     let i = param.index as usize;
 
                     // Handle Self first, so we can adjust the index to match the AST.
@@ -294,7 +294,7 @@ fn create_substs_for_ast_path(&self,
                         } else {
                             self.ty_infer(span).into()
                         }
-                    } else if ty.has_default {
+                    } else if has_default {
                         // No type parameter provided, but a default exists.
 
                         // If we are converting an object type, then the

diff --git a/src/librustc_typeck/check/closure.rs b/src/librustc_typeck/check/closure.rs
index c2ec6475b9c6596bb97cd9227c90f9f8ff89d254..a7cdcae9c0788a63577720163b71590823f6eef6 100644 (file)
--- a/src/librustc_typeck/check/closure.rs
+++ b/src/librustc_typeck/check/closure.rs
@@ -109,7 +109,7 @@ fn check_closure(
                 GenericParamDefKind::Lifetime => {
                     span_bug!(expr.span, "closure has region param")
                 }
-                GenericParamDefKind::Type(_) => {
+                GenericParamDefKind::Type {..} => {
                     self.infcx
                         .next_ty_var(TypeVariableOrigin::ClosureSynthetic(expr.span)).into()
                 }

diff --git a/src/librustc_typeck/check/compare_method.rs b/src/librustc_typeck/check/compare_method.rs
index ba950f90d0a02db5fa5bef9c87761ed0a139c673..f386b7e07c1cd79cdbcca17a7168162b39222b80 100644 (file)
--- a/src/librustc_typeck/check/compare_method.rs
+++ b/src/librustc_typeck/check/compare_method.rs
@@ -730,13 +730,13 @@ fn compare_synthetic_generics<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
     let trait_m_generics = tcx.generics_of(trait_m.def_id);
     let impl_m_type_params = impl_m_generics.params.iter().filter_map(|param| {
         match param.kind {
-            GenericParamDefKind::Type(ty) => Some((param.def_id, ty.synthetic)),
+            GenericParamDefKind::Type { synthetic, .. } => Some((param.def_id, synthetic)),
             GenericParamDefKind::Lifetime => None,
         }
     });
     let trait_m_type_params = trait_m_generics.params.iter().filter_map(|param| {
         match param.kind {
-            GenericParamDefKind::Type(ty) => Some((param.def_id, ty.synthetic)),
+            GenericParamDefKind::Type { synthetic, .. } => Some((param.def_id, synthetic)),
             GenericParamDefKind::Lifetime => None,
         }
     });

diff --git a/src/librustc_typeck/check/method/confirm.rs b/src/librustc_typeck/check/method/confirm.rs
index aa3a166d0656fd71136c0cafe013bb5a7a845da3..7d9f2e094e1af6240fad364d0c745e541a643314 100644 (file)
--- a/src/librustc_typeck/check/method/confirm.rs
+++ b/src/librustc_typeck/check/method/confirm.rs
@@ -331,7 +331,7 @@ fn instantiate_method_substs(&mut self,
                                 self.fcx, lifetime, Some(param)).into();
                         }
                     }
-                    GenericParamDefKind::Type(_) => {
+                    GenericParamDefKind::Type {..} => {
                         if let Some(ast_ty) = provided.as_ref().and_then(|p| {
                             p.types.get(i - parent_substs.len() - own_counts.lifetimes)
                         }) {

diff --git a/src/librustc_typeck/check/method/mod.rs b/src/librustc_typeck/check/method/mod.rs
index 15a8efd5885d77755c2ca725f822e64c5471b913..8ffb6e99fc04ef6a6c69531ab0f5d2473b9c5ea5 100644 (file)
--- a/src/librustc_typeck/check/method/mod.rs
+++ b/src/librustc_typeck/check/method/mod.rs
@@ -257,7 +257,7 @@ pub fn lookup_method_in_trait(&self,
         let substs = Substs::for_item(self.tcx, trait_def_id, |param, _| {
             match param.kind {
                 GenericParamDefKind::Lifetime => {}
-                GenericParamDefKind::Type(_) => {
+                GenericParamDefKind::Type {..} => {
                     if param.index == 0 {
                         return self_ty.into();
                     } else if let Some(ref input_types) = opt_input_types {

diff --git a/src/librustc_typeck/check/method/probe.rs b/src/librustc_typeck/check/method/probe.rs
index 6b860dbe8febbfee9a756afe14eb848d3f613fb0..6cdfb0bccc98642c3a7d509d40b74bdf04c42dfb 100644 (file)
--- a/src/librustc_typeck/check/method/probe.rs
+++ b/src/librustc_typeck/check/method/probe.rs
@@ -1399,7 +1399,7 @@ fn xform_method_sig(&self,
                             // `impl_self_ty()` for an explanation.
                             self.tcx.types.re_erased.into()
                         }
-                        GenericParamDefKind::Type(_) => self.var_for_def(self.span, param),
+                        GenericParamDefKind::Type {..} => self.var_for_def(self.span, param),
                     }
                 }
             });
@@ -1416,7 +1416,7 @@ fn fresh_item_substs(&self, def_id: DefId) -> &'tcx Substs<'tcx> {
         Substs::for_item(self.tcx, def_id, |param, _| {
             match param.kind {
                 GenericParamDefKind::Lifetime => self.tcx.types.re_erased.into(),
-                GenericParamDefKind::Type(_) => {
+                GenericParamDefKind::Type {..} => {
                     self.next_ty_var(TypeVariableOrigin::SubstitutionPlaceholder(
                         self.tcx.def_span(def_id))).into()
                 }

diff --git a/src/librustc_typeck/check/mod.rs b/src/librustc_typeck/check/mod.rs
index b4bd64bfacee45ee1095af41e5f8a58ebe00c4c2..46dbccaa137eae0c49e37185f8bf19b041552327 100644 (file)
--- a/src/librustc_typeck/check/mod.rs
+++ b/src/librustc_typeck/check/mod.rs
@@ -4751,7 +4751,7 @@ pub fn instantiate_value_path(&self,
             let mut i = param.index as usize;
 
             let segment = if i < fn_start {
-                if let GenericParamDefKind::Type(_) = param.kind {
+                if let GenericParamDefKind::Type {..} = param.kind {
                     // Handle Self first, so we can adjust the index to match the AST.
                     if has_self && i == 0 {
                         return opt_self_ty.map(|ty| ty.into()).unwrap_or_else(|| {
@@ -4778,7 +4778,7 @@ pub fn instantiate_value_path(&self,
                         self.re_infer(span, Some(param)).unwrap().into()
                     }
                 }
-                GenericParamDefKind::Type(_) => {
+                GenericParamDefKind::Type {..} => {
                     let (types, infer_types) = segment.map_or((&[][..], true), |(s, _)| {
                         (s.parameters.as_ref().map_or(&[][..], |p| &p.types[..]), s.infer_types)
                     });
@@ -4789,7 +4789,7 @@ pub fn instantiate_value_path(&self,
                     }
 
                     let has_default = match param.kind {
-                        GenericParamDefKind::Type(ty) => ty.has_default,
+                        GenericParamDefKind::Type { has_default, .. } => has_default,
                         _ => unreachable!()
                     };
 
@@ -4925,9 +4925,9 @@ struct ParamRange {
                         GenericParamDefKind::Lifetime => {
                             lt_accepted += 1;
                         }
-                        GenericParamDefKind::Type(ty) => {
+                        GenericParamDefKind::Type { has_default, .. } => {
                             ty_params.accepted += 1;
-                            if !ty.has_default {
+                            if !has_default {
                                 ty_params.required += 1;
                             }
                         }
@@ -5024,12 +5024,12 @@ fn check_impl_trait(&self,
         let segment = segment.map(|(path_segment, generics)| {
             let explicit = !path_segment.infer_types;
             let impl_trait = generics.params.iter().any(|param| {
-                if let ty::GenericParamDefKind::Type(ty) = param.kind {
-                    if let Some(hir::SyntheticTyParamKind::ImplTrait) = ty.synthetic {
-                        return true;
-                    }
+                match param.kind {
+                    ty::GenericParamDefKind::Type {
+                        synthetic: Some(hir::SyntheticTyParamKind::ImplTrait), ..
+                    } => true,
+                    _ => false,
                 }
-                false
             });
 
             if explicit && impl_trait {

diff --git a/src/librustc_typeck/check/wfcheck.rs b/src/librustc_typeck/check/wfcheck.rs
index 0fc8c9cc316aca0188d71b184fcf147e88b7faff..4b4b982b1be411dbb5d2fef2bb0b522ae0855439 100644 (file)
--- a/src/librustc_typeck/check/wfcheck.rs
+++ b/src/librustc_typeck/check/wfcheck.rs
@@ -377,8 +377,8 @@ fn check_where_clauses<'a, 'gcx, 'fcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'gcx>,
     let generics = tcx.generics_of(def_id);
     let is_our_default = |def: &ty::GenericParamDef| {
         match def.kind {
-            GenericParamDefKind::Type(ty) => {
-                ty.has_default && def.index >= generics.parent_count as u32
+            GenericParamDefKind::Type { has_default, .. } => {
+                has_default && def.index >= generics.parent_count as u32
             }
             _ => unreachable!()
         }
@@ -389,7 +389,7 @@ fn check_where_clauses<'a, 'gcx, 'fcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'gcx>,
     // struct Foo<T = Vec<[u32]>> { .. }
     // Here the default `Vec<[u32]>` is not WF because `[u32]: Sized` does not hold.
     for param in &generics.params {
-        if let GenericParamDefKind::Type(_) = param.kind {
+        if let GenericParamDefKind::Type {..} = param.kind {
             if is_our_default(&param) {
                 let ty = fcx.tcx.type_of(param.def_id);
                 // ignore dependent defaults -- that is, where the default of one type
@@ -417,7 +417,7 @@ fn check_where_clauses<'a, 'gcx, 'fcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'gcx>,
                 // All regions are identity.
                 fcx.tcx.mk_param_from_def(param)
             }
-            GenericParamDefKind::Type(_) => {
+            GenericParamDefKind::Type {..} => {
                 // If the param has a default,
                 if is_our_default(param) {
                     let default_ty = fcx.tcx.type_of(param.def_id);
@@ -668,7 +668,7 @@ fn reject_shadowing_parameters(tcx: TyCtxt, def_id: DefId) {
                      .flat_map(|param| {
                          match param.kind {
                              GenericParamDefKind::Lifetime => None,
-                             GenericParamDefKind::Type(_) => Some((param.name, param.def_id)),
+                             GenericParamDefKind::Type {..} => Some((param.name, param.def_id)),
                          }
                      })
                      .collect();

diff --git a/src/librustc_typeck/collect.rs b/src/librustc_typeck/collect.rs
index 4d691de2037cab0ea354281a04ba879a1b710776..d0d147b8e85cd0f4efdfb935865f9b43793aab63 100644 (file)
--- a/src/librustc_typeck/collect.rs
+++ b/src/librustc_typeck/collect.rs
@@ -845,11 +845,11 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                         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 {
+                        kind: ty::GenericParamDefKind::Type {
                             has_default: false,
                             object_lifetime_default: rl::Set1::Empty,
                             synthetic: None,
-                        }),
+                        },
                     });
 
                     allow_defaults = true;
@@ -925,12 +925,12 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
             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 {
+            kind: ty::GenericParamDefKind::Type {
                 has_default: p.default.is_some(),
                 object_lifetime_default:
                     object_lifetime_defaults.as_ref().map_or(rl::Set1::Empty, |o| o[i]),
                 synthetic: p.synthetic,
-            }),
+            },
         }
     }));
 
@@ -950,11 +950,11 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                 name: Symbol::intern(arg).as_interned_str(),
                 def_id,
                 pure_wrt_drop: false,
-                kind: ty::GenericParamDefKind::Type(ty::TypeParamDef {
+                kind: ty::GenericParamDefKind::Type {
                     has_default: false,
                     object_lifetime_default: rl::Set1::Empty,
                     synthetic: None,
-                }),
+                },
             });
         }
 
@@ -965,11 +965,11 @@ fn generics_of<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                     name: Symbol::intern("<upvar>").as_interned_str(),
                     def_id,
                     pure_wrt_drop: false,
-                    kind: ty::GenericParamDefKind::Type(ty::TypeParamDef {
+                    kind: ty::GenericParamDefKind::Type {
                         has_default: false,
                         object_lifetime_default: rl::Set1::Empty,
                         synthetic: None,
-                    }),
+                    },
                 }
             }));
         });

diff --git a/src/librustc_typeck/impl_wf_check.rs b/src/librustc_typeck/impl_wf_check.rs
index 80dde814c6638a529eee689fc4b0e552150f37cd..7b7cb2549797878ecc0da1335de9c3814b56fd08 100644 (file)
--- a/src/librustc_typeck/impl_wf_check.rs
+++ b/src/librustc_typeck/impl_wf_check.rs
@@ -116,7 +116,7 @@ fn enforce_impl_params_are_constrained<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
     for param in &impl_generics.params {
         match param.kind {
             // Disallow ANY unconstrained type parameters.
-            ty::GenericParamDefKind::Type(_) => {
+            ty::GenericParamDefKind::Type {..} => {
                 let param_ty = ty::ParamTy::for_def(param);
                 if !input_parameters.contains(&ctp::Parameter::from(param_ty)) {
                     report_unused_parameter(tcx,

diff --git a/src/librustdoc/clean/auto_trait.rs b/src/librustdoc/clean/auto_trait.rs
index 73a7e0e690fe92399e9ced4f24d6f0d870fe980d..da749fca2a953524f619a2ea94286a97acd2f0c9 100644 (file)
--- a/src/librustdoc/clean/auto_trait.rs
+++ b/src/librustdoc/clean/auto_trait.rs
@@ -263,7 +263,7 @@ fn generics_to_path_params(&self, generics: ty::Generics) -> hir::PathParameters
                         name,
                     });
                 }
-                ty::GenericParamDefKind::Type(_) => {
+                ty::GenericParamDefKind::Type {..} => {
                     types.push(P(self.ty_param_to_ty(param.clone())));
                 }
             }

diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index ae53b9ded4eee84d6525ce06cfb5c9d8ace301ae..d4c1ba63a8c9806c6b9e5c61389f1e935fbb3583 100644 (file)
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -1340,7 +1340,7 @@ impl<'tcx> Clean<TyParam> for ty::GenericParamDef {
     fn clean(&self, cx: &DocContext) -> TyParam {
         cx.renderinfo.borrow_mut().external_typarams.insert(self.def_id, self.name.clean(cx));
         let has_default = match self.kind {
-            ty::GenericParamDefKind::Type(ty) => ty.has_default,
+            ty::GenericParamDefKind::Type { has_default, .. } => has_default,
             _ => panic!("tried to convert a non-type GenericParamDef as a type")
         };
         TyParam {
@@ -1827,7 +1827,7 @@ fn clean(&self, cx: &DocContext) -> Generics {
         // predicates field (see rustc_typeck::collect::ty_generics), so remove
         // them.
         let stripped_typarams = gens.params.iter().filter_map(|param| {
-            if let ty::GenericParamDefKind::Type(_) = param.kind {
+            if let ty::GenericParamDefKind::Type {..} = param.kind {
                 if param.name == keywords::SelfType.name().as_str() {
                     assert_eq!(param.index, 0);
                     None