Lift bounds into GenericParam

Author: varkor

src/librustc/hir/intravisit.rs

@@ -314,7 +314,7 @@ pub trait Visitor<'v> : Sized {
     fn visit_trait_ref(&mut self, t: &'v TraitRef) {
         walk_trait_ref(self, t)
     }
-    fn visit_ty_param_bound(&mut self, bounds: &'v TyParamBound) {
+    fn visit_ty_param_bound(&mut self, bounds: &'v ParamBound) {
         walk_ty_param_bound(self, bounds)
     }
     fn visit_poly_trait_ref(&mut self, t: &'v PolyTraitRef, m: TraitBoundModifier) {
@@ -731,12 +731,12 @@ pub fn walk_foreign_item<'v, V: Visitor<'v>>(visitor: &mut V, foreign_item: &'v
     walk_list!(visitor, visit_attribute, &foreign_item.attrs);
 }
 
-pub fn walk_ty_param_bound<'v, V: Visitor<'v>>(visitor: &mut V, bound: &'v TyParamBound) {
+pub fn walk_ty_param_bound<'v, V: Visitor<'v>>(visitor: &mut V, bound: &'v ParamBound) {
     match *bound {
         TraitTyParamBound(ref typ, modifier) => {
             visitor.visit_poly_trait_ref(typ, modifier);
         }
-        RegionTyParamBound(ref lifetime) => {
+        Outlives(ref lifetime) => {
             visitor.visit_lifetime(lifetime);
         }
     }
@@ -759,11 +759,11 @@ pub fn walk_generic_param<'v, V: Visitor<'v>>(visitor: &mut V, param: &'v Generi
         }
         GenericParamKind::Type { name, ref bounds, ref default, ref attrs, .. } => {
             visitor.visit_name(param.span, name);
-            walk_list!(visitor, visit_ty_param_bound, bounds);
             walk_list!(visitor, visit_ty, default);
             walk_list!(visitor, visit_attribute, attrs.iter());
         }
     }
+    walk_list!(visitor, visit_ty_param_bound, &param.bounds);
 }
 
 pub fn walk_generics<'v, V: Visitor<'v>>(visitor: &mut V, generics: &'v Generics) {

src/librustc/hir/lowering.rs

@@ -701,9 +701,9 @@ impl<'a> LoweringContext<'a> {
                     id: def_node_id,
                     span,
                     pure_wrt_drop: false,
+                    bounds: vec![].into(),
                     kind: hir::GenericParamKind::Lifetime {
                         name: hir_name,
-                        bounds: vec![].into(),
                         in_band: true,
                         lifetime: hir::Lifetime {
                             id: def_node_id,
@@ -1127,7 +1127,7 @@ impl<'a> LoweringContext<'a> {
                             Some(self.lower_poly_trait_ref(ty, itctx))
                         }
                         TraitTyParamBound(_, TraitBoundModifier::Maybe) => None,
-                        RegionTyParamBound(ref lifetime) => {
+                        Outlives(ref lifetime) => {
                             if lifetime_bound.is_none() {
                                 lifetime_bound = Some(self.lower_lifetime(lifetime));
                             }
@@ -1246,16 +1246,16 @@ impl<'a> LoweringContext<'a> {
                             span,
                         );
 
-                        let hir_bounds = self.lower_bounds(bounds, itctx);
+                        let hir_bounds = self.lower_param_bounds(bounds, itctx);
                         // Set the name to `impl Bound1 + Bound2`
                         let name = Symbol::intern(&pprust::ty_to_string(t));
                         self.in_band_ty_params.push(hir::GenericParam {
                             id: def_node_id,
                             span,
                             pure_wrt_drop: false,
+                            bounds: hir_bounds,
                             kind: hir::GenericParamKind::Type {
                                 name,
-                                bounds: hir_bounds,
                                 default: None,
                                 synthetic: Some(hir::SyntheticTyParamKind::ImplTrait),
                                 attrs: P::new(),
@@ -1299,7 +1299,7 @@ impl<'a> LoweringContext<'a> {
         &mut self,
         exist_ty_id: NodeId,
         parent_index: DefIndex,
-        bounds: &hir::TyParamBounds,
+        bounds: &hir::ParamBounds,
     ) -> (HirVec<hir::Lifetime>, HirVec<hir::GenericParam>) {
         // This visitor walks over impl trait bounds and creates defs for all lifetimes which
         // appear in the bounds, excluding lifetimes that are created within the bounds.
@@ -1420,9 +1420,9 @@ impl<'a> LoweringContext<'a> {
                         id: def_node_id,
                         span: lifetime.span,
                         pure_wrt_drop: false,
+                        bounds: vec![].into(),
                         kind: hir::GenericParamKind::Lifetime {
                             name,
-                            bounds: vec![].into(),
                             in_band: false,
                             lifetime: hir::Lifetime {
                                 id: def_node_id,
@@ -1882,18 +1882,18 @@ impl<'a> LoweringContext<'a> {
         })
     }
 
-    fn lower_ty_param_bound(
+    fn lower_param_bound(
         &mut self,
-        tpb: &TyParamBound,
+        tpb: &ParamBound,
         itctx: ImplTraitContext,
-    ) -> hir::TyParamBound {
+    ) -> hir::ParamBound {
         match *tpb {
             TraitTyParamBound(ref ty, modifier) => hir::TraitTyParamBound(
                 self.lower_poly_trait_ref(ty, itctx),
                 self.lower_trait_bound_modifier(modifier),
             ),
-            RegionTyParamBound(ref lifetime) => {
-                hir::RegionTyParamBound(self.lower_lifetime(lifetime))
+            Outlives(ref lifetime) => {
+                hir::Outlives(self.lower_lifetime(lifetime))
             }
         }
     }
@@ -1935,19 +1935,20 @@ impl<'a> LoweringContext<'a> {
     fn lower_generic_params(
         &mut self,
         params: &Vec<GenericParam>,
-        add_bounds: &NodeMap<Vec<TyParamBound>>,
+        add_bounds: &NodeMap<Vec<ParamBound>>,
         itctx: ImplTraitContext,
     ) -> hir::HirVec<hir::GenericParam> {
         params.iter().map(|param| self.lower_generic_param(param, add_bounds, itctx)).collect()
     }
 
     fn lower_generic_param(&mut self,
                            param: &GenericParam,
-                           add_bounds: &NodeMap<Vec<TyParamBound>>,
+                           add_bounds: &NodeMap<Vec<ParamBound>>,
                            itctx: ImplTraitContext)
                            -> hir::GenericParam {
+        let mut bounds = self.lower_param_bounds(&param.bounds, itctx);
         match param.kind {
-            GenericParamKind::Lifetime { ref bounds, ref lifetime } => {
+            GenericParamKind::Lifetime { ref lifetime } => {
                 let was_collecting_in_band = self.is_collecting_in_band_lifetimes;
                 self.is_collecting_in_band_lifetimes = false;
 
@@ -1956,9 +1957,9 @@ impl<'a> LoweringContext<'a> {
                     id: lifetime.id,
                     span: lifetime.span,
                     pure_wrt_drop: attr::contains_name(&param.attrs, "may_dangle"),
+                    bounds,
                     kind: hir::GenericParamKind::Lifetime {
                         name: lifetime.name,
-                        bounds: bounds.iter().map(|lt| self.lower_lifetime(lt)).collect(),
                         in_band: false,
                         lifetime,
                     }
@@ -1968,7 +1969,7 @@ impl<'a> LoweringContext<'a> {
 
                 param
             }
-            GenericParamKind::Type { ref bounds, ref default } => {
+            GenericParamKind::Type { ref default, .. } => {
                 let mut name = self.lower_ident(param.ident);
 
                 // Don't expose `Self` (recovered "keyword used as ident" parse error).
@@ -1978,21 +1979,20 @@ impl<'a> LoweringContext<'a> {
                     name = Symbol::gensym("Self");
                 }
 
-                let mut bounds = self.lower_bounds(bounds, itctx);
                 let add_bounds = add_bounds.get(&param.id).map_or(&[][..], |x| &x);
                 if !add_bounds.is_empty() {
                     bounds = bounds.into_iter()
-                                   .chain(self.lower_bounds(add_bounds, itctx).into_iter())
+                                   .chain(self.lower_param_bounds(add_bounds, itctx).into_iter())
                                    .collect();
                 }
 
                 hir::GenericParam {
                     id: self.lower_node_id(param.id).node_id,
                     span: param.ident.span,
                     pure_wrt_drop: attr::contains_name(&param.attrs, "may_dangle"),
+                    bounds,
                     kind: hir::GenericParamKind::Type {
                         name,
-                        bounds,
                         default: default.as_ref().map(|x| {
                             self.lower_ty(x, ImplTraitContext::Disallowed)
                         }),
@@ -2107,7 +2107,7 @@ impl<'a> LoweringContext<'a> {
                                     // Ignore `?Trait` bounds.
                                     // Tthey were copied into type parameters already.
                                     TraitTyParamBound(_, TraitBoundModifier::Maybe) => None,
-                                    _ => Some(this.lower_ty_param_bound(
+                                    _ => Some(this.lower_param_bound(
                                         bound,
                                         ImplTraitContext::Disallowed,
                                     )),
@@ -2228,15 +2228,9 @@ impl<'a> LoweringContext<'a> {
         }
     }
 
-    fn lower_bounds(
-        &mut self,
-        bounds: &[TyParamBound],
-        itctx: ImplTraitContext,
-    ) -> hir::TyParamBounds {
-        bounds
-            .iter()
-            .map(|bound| self.lower_ty_param_bound(bound, itctx))
-            .collect()
+    fn lower_param_bounds(&mut self, bounds: &[ParamBound], itctx: ImplTraitContext)
+        -> hir::ParamBounds {
+        bounds.iter().map(|bound| self.lower_param_bound(bound, itctx)).collect()
     }
 
     fn lower_block(&mut self, b: &Block, targeted_by_break: bool) -> P<hir::Block> {
@@ -2422,7 +2416,7 @@ impl<'a> LoweringContext<'a> {
                 )
             }
             ItemKind::Trait(is_auto, unsafety, ref generics, ref bounds, ref items) => {
-                let bounds = self.lower_bounds(bounds, ImplTraitContext::Disallowed);
+                let bounds = self.lower_param_bounds(bounds, ImplTraitContext::Disallowed);
                 let items = items
                     .iter()
                     .map(|item| self.lower_trait_item_ref(item))
@@ -2437,7 +2431,7 @@ impl<'a> LoweringContext<'a> {
             }
             ItemKind::TraitAlias(ref generics, ref bounds) => hir::ItemTraitAlias(
                 self.lower_generics(generics, ImplTraitContext::Disallowed),
-                self.lower_bounds(bounds, ImplTraitContext::Disallowed),
+                self.lower_param_bounds(bounds, ImplTraitContext::Disallowed),
             ),
             ItemKind::MacroDef(..) | ItemKind::Mac(..) => panic!("Shouldn't still be around"),
         }
@@ -2664,7 +2658,7 @@ impl<'a> LoweringContext<'a> {
             TraitItemKind::Type(ref bounds, ref default) => (
                 self.lower_generics(&i.generics, ImplTraitContext::Disallowed),
                 hir::TraitItemKind::Type(
-                    self.lower_bounds(bounds, ImplTraitContext::Disallowed),
+                    self.lower_param_bounds(bounds, ImplTraitContext::Disallowed),
                     default
                         .as_ref()
                         .map(|x| self.lower_ty(x, ImplTraitContext::Disallowed)),

src/librustc/hir/mod.rs

@@ -22,7 +22,7 @@ pub use self::Mutability::*;
 pub use self::PrimTy::*;
 pub use self::Stmt_::*;
 pub use self::Ty_::*;
-pub use self::TyParamBound::*;
+pub use self::ParamBound::*;
 pub use self::UnOp::*;
 pub use self::UnsafeSource::*;
 pub use self::Visibility::{Public, Inherited};
@@ -416,41 +416,42 @@ impl GenericArgs {
     }
 }
 
+/// A modifier on a bound, currently this is only used for `?Sized`, where the
+/// modifier is `Maybe`. Negative bounds should also be handled here.
+#[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
+pub enum TraitBoundModifier {
+    None,
+    Maybe,
+}
+
+pub type Outlives = Lifetime;
+
 /// The AST represents all type param bounds as types.
 /// typeck::collect::compute_bounds matches these against
 /// the "special" built-in traits (see middle::lang_items) and
 /// detects Copy, Send and Sync.
 #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
-pub enum TyParamBound {
+pub enum ParamBound {
     TraitTyParamBound(PolyTraitRef, TraitBoundModifier),
-    RegionTyParamBound(Lifetime),
+    Outlives(Lifetime),
 }
 
-impl TyParamBound {
+impl ParamBound {
     pub fn span(&self) -> Span {
         match self {
             &TraitTyParamBound(ref t, ..) => t.span,
-            &RegionTyParamBound(ref l) => l.span,
+            &Outlives(ref l) => l.span,
         }
     }
 }
 
-/// A modifier on a bound, currently this is only used for `?Sized`, where the
-/// modifier is `Maybe`. Negative bounds should also be handled here.
-#[derive(Copy, Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
-pub enum TraitBoundModifier {
-    None,
-    Maybe,
-}
-
-pub type TyParamBounds = HirVec<TyParamBound>;
+pub type ParamBounds = HirVec<ParamBound>;
 
 #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
 pub enum GenericParamKind {
     /// A lifetime definition, eg `'a: 'b + 'c + 'd`.
     Lifetime {
         name: LifetimeName,
-        bounds: HirVec<Lifetime>,
         // Indicates that the lifetime definition was synthetically added
         // as a result of an in-band lifetime usage like:
         // `fn foo(x: &'a u8) -> &'a u8 { x }`
@@ -460,7 +461,6 @@ pub enum GenericParamKind {
     },
     Type {
         name: Name,
-        bounds: TyParamBounds,
         default: Option<P<Ty>>,
         synthetic: Option<SyntheticTyParamKind>,
         attrs: HirVec<Attribute>,
@@ -470,6 +470,7 @@ pub enum GenericParamKind {
 #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
 pub struct GenericParam {
     pub id: NodeId,
+    pub bounds: ParamBounds,
     pub span: Span,
     pub pure_wrt_drop: bool,
 
@@ -587,7 +588,7 @@ pub struct WhereBoundPredicate {
     /// The type being bounded
     pub bounded_ty: P<Ty>,
     /// Trait and lifetime bounds (`Clone+Send+'static`)
-    pub bounds: TyParamBounds,
+    pub bounds: ParamBounds,
 }
 
 /// A lifetime predicate, e.g. `'a: 'b+'c`
@@ -1554,7 +1555,7 @@ pub enum TraitItemKind {
     Method(MethodSig, TraitMethod),
     /// An associated type with (possibly empty) bounds and optional concrete
     /// type
-    Type(TyParamBounds, Option<P<Ty>>),
+    Type(ParamBounds, Option<P<Ty>>),
 }
 
 // The bodies for items are stored "out of line", in a separate
@@ -1639,7 +1640,7 @@ pub struct BareFnTy {
 #[derive(Clone, PartialEq, Eq, RustcEncodable, RustcDecodable, Hash, Debug)]
 pub struct ExistTy {
     pub generics: Generics,
-    pub bounds: TyParamBounds,
+    pub bounds: ParamBounds,
     pub impl_trait_fn: Option<DefId>,
 }
 
@@ -2048,9 +2049,9 @@ pub enum Item_ {
     /// A union definition, e.g. `union Foo<A, B> {x: A, y: B}`
     ItemUnion(VariantData, Generics),
     /// Represents a Trait Declaration
-    ItemTrait(IsAuto, Unsafety, Generics, TyParamBounds, HirVec<TraitItemRef>),
+    ItemTrait(IsAuto, Unsafety, Generics, ParamBounds, HirVec<TraitItemRef>),
     /// Represents a Trait Alias Declaration
-    ItemTraitAlias(Generics, TyParamBounds),
+    ItemTraitAlias(Generics, ParamBounds),
 
     /// An implementation, eg `impl<A> Trait for Foo { .. }`
     ItemImpl(Unsafety,