rustdoc: Fix up some bugs with bounds

src/librustdoc/clean/inline.rs

@@ -324,7 +324,8 @@ fn build_impl(cx: &DocContext, tcx: &ty::ctxt,
             trait_: associated_trait.clean(cx).map(|bound| {
                 match bound {
                     clean::TraitBound(ty) => ty,
-                    clean::RegionBound => unreachable!(),
+                    clean::UnboxedFnBound(..) |
+                    clean::RegionBound(..) => unreachable!(),
                 }
             }),
             for_: ty.ty.clean(cx),

src/librustdoc/clean/mod.rs

@@ -462,6 +462,7 @@ impl Clean<TyParam> for ty::TypeParameterDef {
     fn clean(&self, cx: &DocContext) -> TyParam {
         cx.external_typarams.borrow_mut().as_mut().unwrap()
           .insert(self.def_id, self.ident.clean(cx));
+
         TyParam {
             name: self.ident.clean(cx),
             did: self.def_id,
@@ -473,26 +474,25 @@ impl Clean<TyParam> for ty::TypeParameterDef {
 
 #[deriving(Clone, Encodable, Decodable, PartialEq)]
 pub enum TyParamBound {
-    RegionBound, // FIXME(#16518) -- need to include name of actual region
+    RegionBound(Lifetime),
+    UnboxedFnBound(UnboxedFnType),
     TraitBound(Type)
 }
 
 impl Clean<TyParamBound> for ast::TyParamBound {
     fn clean(&self, cx: &DocContext) -> TyParamBound {
         match *self {
-            ast::RegionTyParamBound(_) => RegionBound,
-            ast::UnboxedFnTyParamBound(_) => {
-                // FIXME(pcwalton): Wrong.
-                RegionBound
-            }
+            ast::RegionTyParamBound(lt) => RegionBound(lt.clean(cx)),
+            ast::UnboxedFnTyParamBound(ref ty) => { UnboxedFnBound(ty.clean(cx)) },
             ast::TraitTyParamBound(ref t) => TraitBound(t.clean(cx)),
         }
     }
 }
 
 impl Clean<Vec<TyParamBound>> for ty::ExistentialBounds {
     fn clean(&self, cx: &DocContext) -> Vec<TyParamBound> {
-        let mut vec = vec!(RegionBound);
+        let mut vec = vec![];
+        self.region_bound.clean(cx).map(|b| vec.push(RegionBound(b)));
         for bb in self.builtin_bounds.iter() {
             vec.push(bb.clean(cx));
         }
@@ -521,7 +521,7 @@ impl Clean<TyParamBound> for ty::BuiltinBound {
     fn clean(&self, cx: &DocContext) -> TyParamBound {
         let tcx = match cx.tcx_opt() {
             Some(tcx) => tcx,
-            None => return RegionBound,
+            None => return RegionBound(Lifetime::statik())
         };
         let empty = subst::Substs::empty();
         let (did, path) = match *self {
@@ -554,7 +554,7 @@ impl Clean<TyParamBound> for ty::TraitRef {
     fn clean(&self, cx: &DocContext) -> TyParamBound {
         let tcx = match cx.tcx_opt() {
             Some(tcx) => tcx,
-            None => return RegionBound,
+            None => return RegionBound(Lifetime::statik())
         };
         let fqn = csearch::get_item_path(tcx, self.def_id);
         let fqn = fqn.into_iter().map(|i| i.to_string())
@@ -582,19 +582,37 @@ impl Clean<Vec<TyParamBound>> for ty::ParamBounds {
         for t in self.trait_bounds.iter() {
             v.push(t.clean(cx));
         }
+        for r in self.region_bounds.iter().filter_map(|r| r.clean(cx)) {
+            v.push(RegionBound(r));
+        }
         return v;
     }
 }
 
 impl Clean<Option<Vec<TyParamBound>>> for subst::Substs {
     fn clean(&self, cx: &DocContext) -> Option<Vec<TyParamBound>> {
         let mut v = Vec::new();
-        v.extend(self.regions().iter().map(|_| RegionBound));
+        v.extend(self.regions().iter().filter_map(|r| r.clean(cx)).map(RegionBound));
         v.extend(self.types.iter().map(|t| TraitBound(t.clean(cx))));
         if v.len() > 0 {Some(v)} else {None}
     }
 }
 
+#[deriving(Clone, Encodable, Decodable, PartialEq)]
+pub struct UnboxedFnType {
+    pub path: Path,
+    pub decl: FnDecl
+}
+
+impl Clean<UnboxedFnType> for ast::UnboxedFnBound {
+    fn clean(&self, cx: &DocContext) -> UnboxedFnType {
+        UnboxedFnType {
+            path: self.path.clean(cx),
+            decl: self.decl.clean(cx)
+        }
+    }
+}
+
 #[deriving(Clone, Encodable, Decodable, PartialEq)]
 pub struct Lifetime(String);
 
@@ -604,6 +622,10 @@ impl Lifetime {
         let s: &'a str = s.as_slice();
         return s;
     }
+
+    pub fn statik() -> Lifetime {
+        Lifetime("'static".to_string())
+    }
 }
 
 impl Clean<Lifetime> for ast::Lifetime {
@@ -627,7 +649,7 @@ impl Clean<Lifetime> for ty::RegionParameterDef {
 impl Clean<Option<Lifetime>> for ty::Region {
     fn clean(&self, cx: &DocContext) -> Option<Lifetime> {
         match *self {
-            ty::ReStatic => Some(Lifetime("'static".to_string())),
+            ty::ReStatic => Some(Lifetime::statik()),
             ty::ReLateBound(_, ty::BrNamed(_, name)) =>
                 Some(Lifetime(token::get_name(name).get().to_string())),
             ty::ReEarlyBound(_, _, _, name) => Some(Lifetime(name.clean(cx))),

src/librustdoc/html/format.rs

@@ -140,8 +140,11 @@ impl fmt::Show for clean::Lifetime {
 impl fmt::Show for clean::TyParamBound {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
-            clean::RegionBound => {
-                f.write("'static".as_bytes())
+            clean::RegionBound(ref lt) => {
+                write!(f, "{}", *lt)
+            }
+            clean::UnboxedFnBound(ref ty) => {
+                write!(f, "{}{}", ty.path, ty.decl)
             }
             clean::TraitBound(ref ty) => {
                 write!(f, "{}", *ty)
@@ -401,7 +404,8 @@ impl fmt::Show for clean::Type {
                            let mut ret = String::new();
                            for bound in decl.bounds.iter() {
                                 match *bound {
-                                    clean::RegionBound => {}
+                                    clean::RegionBound(..) |
+                                    clean::UnboxedFnBound(..) => {}
                                     clean::TraitBound(ref t) => {
                                         if ret.len() == 0 {
                                             ret.push_str(": ");