Changes to RustDoc

nrc · nrc · commit c4640a2a6933 · 2014-12-26T10:54:24.000+13:00
diff --git a/src/librustdoc/clean/inline.rs b/src/librustdoc/clean/inline.rs
@@ -163,13 +163,12 @@ pub fn build_external_trait(cx: &DocContext, tcx: &ty::ctxt,
         }
     });
     let trait_def = ty::lookup_trait_def(tcx, did);
-    let (bounds, default_unbound) = trait_def.bounds.clean(cx);
+    let bounds = trait_def.bounds.clean(cx);
     clean::Trait {
         unsafety: def.unsafety,
         generics: (&def.generics, subst::TypeSpace).clean(cx),
         items: items.collect(),
         bounds: bounds,
-        default_unbound: default_unbound
     }
 }
 
@@ -328,7 +327,7 @@ fn build_impl(cx: &DocContext, tcx: &ty::ctxt,
             derived: clean::detect_derived(attrs.as_slice()),
             trait_: associated_trait.clean(cx).map(|bound| {
                 match bound {
-                    clean::TraitBound(polyt) => polyt.trait_,
+                    clean::TraitBound(polyt, _) => polyt.trait_,
                     clean::RegionBound(..) => unreachable!(),
                 }
             }),
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
@@ -458,8 +458,6 @@ pub struct TyParam {
     pub did: ast::DefId,
     pub bounds: Vec<TyParamBound>,
     pub default: Option<Type>,
-    /// An optional default bound on the parameter which is unbound, like `Sized?`
-    pub default_unbound: Option<Type>
 }
 
 impl Clean<TyParam> for ast::TyParam {
@@ -469,7 +467,6 @@ impl Clean<TyParam> for ast::TyParam {
             did: ast::DefId { krate: ast::LOCAL_CRATE, node: self.id },
             bounds: self.bounds.clean(cx),
             default: self.default.clean(cx),
-            default_unbound: self.unbound.clean(cx)
         }
     }
 }
@@ -478,28 +475,27 @@ impl<'tcx> Clean<TyParam> for ty::TypeParameterDef<'tcx> {
     fn clean(&self, cx: &DocContext) -> TyParam {
         cx.external_typarams.borrow_mut().as_mut().unwrap()
           .insert(self.def_id, self.name.clean(cx));
-        let (bounds, default_unbound) = self.bounds.clean(cx);
+        let bounds = self.bounds.clean(cx);
         TyParam {
             name: self.name.clean(cx),
             did: self.def_id,
             bounds: bounds,
             default: self.default.clean(cx),
-            default_unbound: default_unbound
         }
     }
 }
 
 #[deriving(Clone, RustcEncodable, RustcDecodable, PartialEq)]
 pub enum TyParamBound {
     RegionBound(Lifetime),
-    TraitBound(PolyTrait)
+    TraitBound(PolyTrait, ast::TraitBoundModifier)
 }
 
 impl Clean<TyParamBound> for ast::TyParamBound {
     fn clean(&self, cx: &DocContext) -> TyParamBound {
         match *self {
             ast::RegionTyParamBound(lt) => RegionBound(lt.clean(cx)),
-            ast::TraitTyParamBound(ref t) => TraitBound(t.clean(cx)),
+            ast::TraitTyParamBound(ref t, modifier) => TraitBound(t.clean(cx), modifier),
         }
     }
 }
@@ -600,7 +596,7 @@ impl Clean<TyParamBound> for ty::BuiltinBound {
                 did: did,
             },
             lifetimes: vec![]
-        })
+        }, ast::TraitBoundModifier::None)
     }
 }
 
@@ -648,37 +644,20 @@ impl<'tcx> Clean<TyParamBound> for ty::TraitRef<'tcx> {
         TraitBound(PolyTrait {
             trait_: ResolvedPath { path: path, typarams: None, did: self.def_id, },
             lifetimes: late_bounds
-        })
+        }, ast::TraitBoundModifier::None)
     }
 }
 
-// Returns (bounds, default_unbound)
-impl<'tcx> Clean<(Vec<TyParamBound>, Option<Type>)> for ty::ParamBounds<'tcx> {
-    fn clean(&self, cx: &DocContext) -> (Vec<TyParamBound>, Option<Type>) {
+impl<'tcx> Clean<Vec<TyParamBound>> for ty::ParamBounds<'tcx> {
+    fn clean(&self, cx: &DocContext) -> Vec<TyParamBound> {
         let mut v = Vec::new();
-        let mut has_sized_bound = false;
-        for b in self.builtin_bounds.iter() {
-            if b != ty::BoundSized {
-                v.push(b.clean(cx));
-            } else {
-                has_sized_bound = true;
-            }
-        }
         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));
         }
-        if has_sized_bound {
-            (v, None)
-        } else {
-            let ty = match ty::BoundSized.clean(cx) {
-                TraitBound(polyt) => polyt.trait_,
-                _ => unreachable!()
-            };
-            (v, Some(ty))
-        }
+        v
     }
 }
 
@@ -689,7 +668,7 @@ impl<'tcx> Clean<Option<Vec<TyParamBound>>> for subst::Substs<'tcx> {
         v.extend(self.types.iter().map(|t| TraitBound(PolyTrait {
             trait_: t.clean(cx),
             lifetimes: vec![]
-        })));
+        }, ast::TraitBoundModifier::None)));
         if v.len() > 0 {Some(v)} else {None}
     }
 }
@@ -1047,8 +1026,6 @@ pub struct Trait {
     pub items: Vec<TraitMethod>,
     pub generics: Generics,
     pub bounds: Vec<TyParamBound>,
-    /// An optional default bound not required for `Self`, like `Sized?`
-    pub default_unbound: Option<Type>
 }
 
 impl Clean<Item> for doctree::Trait {
@@ -1065,7 +1042,6 @@ impl Clean<Item> for doctree::Trait {
                 items: self.items.clean(cx),
                 generics: self.generics.clean(cx),
                 bounds: self.bounds.clean(cx),
-                default_unbound: self.default_unbound.clean(cx)
             }),
         }
     }
@@ -2412,7 +2388,6 @@ impl Clean<Item> for ty::AssociatedType {
                 },
                 bounds: vec![],
                 default: None,
-                default_unbound: None
             }),
             visibility: None,
             def_id: self.def_id,
diff --git a/src/librustdoc/doctree.rs b/src/librustdoc/doctree.rs
@@ -178,7 +178,6 @@ pub struct Trait {
     pub whence: Span,
     pub vis: ast::Visibility,
     pub stab: Option<attr::Stability>,
-    pub default_unbound: Option<ast::TraitRef> // FIXME(tomjakubowski)
 }
 
 pub struct Impl {
diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs
@@ -97,9 +97,6 @@ impl fmt::Show for clean::Generics {
                 if i > 0 {
                     try!(f.write(", ".as_bytes()))
                 }
-                if let Some(ref unbound) = tp.default_unbound {
-                    try!(write!(f, "{}? ", unbound));
-                };
                 try!(f.write(tp.name.as_bytes()));
 
                 if tp.bounds.len() > 0 {
@@ -182,8 +179,12 @@ impl fmt::Show for clean::TyParamBound {
             clean::RegionBound(ref lt) => {
                 write!(f, "{}", *lt)
             }
-            clean::TraitBound(ref ty) => {
-                write!(f, "{}", *ty)
+            clean::TraitBound(ref ty, modifier) => {
+                let modifier_str = match modifier {
+                    ast::TraitBoundModifier::None => "",
+                    ast::TraitBoundModifier::Maybe => "?",
+                };
+                write!(f, "{}{}", modifier_str, *ty)
             }
         }
     }
@@ -458,12 +459,15 @@ impl fmt::Show for clean::Type {
                            for bound in decl.bounds.iter() {
                                 match *bound {
                                     clean::RegionBound(..) => {}
-                                    clean::TraitBound(ref t) => {
+                                    clean::TraitBound(ref t, modifier) => {
                                         if ret.len() == 0 {
                                             ret.push_str(": ");
                                         } else {
                                             ret.push_str(" + ");
                                         }
+                                        if modifier == ast::TraitBoundModifier::Maybe {
+                                            ret.push_str("?");
+                                        }
                                         ret.push_str(format!("{}",
                                                              *t).as_slice());
                                     }
diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs
@@ -1679,9 +1679,6 @@ fn item_function(w: &mut fmt::Formatter, it: &clean::Item,
 fn item_trait(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
               t: &clean::Trait) -> fmt::Result {
     let mut bounds = String::new();
-    if let Some(ref ty) = t.default_unbound {
-        bounds.push_str(format!(" for {}?", ty).as_slice());
-    }
     if t.bounds.len() > 0 {
         if bounds.len() > 0 {
             bounds.push(' ');
diff --git a/src/librustdoc/visit_ast.rs b/src/librustdoc/visit_ast.rs
@@ -322,7 +322,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
                 };
                 om.constants.push(s);
             },
-            ast::ItemTrait(unsafety, ref gen, ref def_ub, ref b, ref items) => {
+            ast::ItemTrait(unsafety, ref gen, ref b, ref items) => {
                 let t = Trait {
                     unsafety: unsafety,
                     name: name,
@@ -334,7 +334,6 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
                     whence: item.span,
                     vis: item.vis,
                     stab: self.stability(item.id),
-                    default_unbound: def_ub.clone()
                 };
                 om.traits.push(t);
             },
diff --git a/src/libsyntax/print/pprust.rs b/src/libsyntax/print/pprust.rs
@@ -965,13 +965,18 @@ impl<'a> State<'a> {
                 try!(self.word_nbsp("trait"));
                 try!(self.print_ident(item.ident));
                 try!(self.print_generics(generics));
-                // TODO find and print the unbound, remove it from bounds
-                /*if let &Some(ref tref) = unbound {
-                    try!(space(&mut self.s));
-                    try!(self.word_space("for ?"));
-                    try!(self.print_trait_ref(tref));
-                }*/
-                try!(self.print_bounds(":", bounds[]));
+                let bounds: Vec<_> = bounds.iter().map(|b| b.clone()).collect();
+                let mut real_bounds = Vec::with_capacity(bounds.len());
+                for b in bounds.into_iter() {
+                    if let TraitTyParamBound(ref ptr, ast::TraitBoundModifier::Maybe) = b {
+                        try!(space(&mut self.s));
+                        try!(self.word_space("for ?"));
+                        try!(self.print_trait_ref(&ptr.trait_ref));
+                    } else {
+                        real_bounds.push(b);
+                    }
+                }
+                try!(self.print_bounds(":", real_bounds[]));
                 try!(self.print_where_clause(generics));
                 try!(word(&mut self.s, " "));
                 try!(self.bopen());

Original file line number	Diff line number	Diff line change
`@@ -163,13 +163,12 @@ pub fn build_external_trait(cx: &DocContext, tcx: &ty::ctxt,`
`163`	`163`	`}`
`164`	`164`	`});`
`165`	`165`	`let trait_def = ty::lookup_trait_def(tcx, did);`
`166`		`- let (bounds, default_unbound) = trait_def.bounds.clean(cx);`
	`166`	`+ let bounds = trait_def.bounds.clean(cx);`
`167`	`167`	`clean::Trait {`
`168`	`168`	`unsafety: def.unsafety,`
`169`	`169`	`generics: (&def.generics, subst::TypeSpace).clean(cx),`
`170`	`170`	`items: items.collect(),`
`171`	`171`	`bounds: bounds,`
`172`		`- default_unbound: default_unbound`
`173`	`172`	`}`
`174`	`173`	`}`
`175`	`174`
`@@ -328,7 +327,7 @@ fn build_impl(cx: &DocContext, tcx: &ty::ctxt,`
`328`	`327`	`derived: clean::detect_derived(attrs.as_slice()),`
`329`	`328`	`trait_: associated_trait.clean(cx).map(\|bound\| {`
`330`	`329`	`match bound {`
`331`		`- clean::TraitBound(polyt) => polyt.trait_,`
	`330`	`+ clean::TraitBound(polyt, _) => polyt.trait_,`
`332`	`331`	`clean::RegionBound(..) => unreachable!(),`
`333`	`332`	`}`
`334`	`333`	`}),`
Original file line number	Diff line number	Diff line change
`@@ -458,8 +458,6 @@ pub struct TyParam {`
`458`	`458`	`pub did: ast::DefId,`
`459`	`459`	`pub bounds: Vec<TyParamBound>,`
`460`	`460`	`pub default: Option<Type>,`
`461`		- /// An optional default bound on the parameter which is unbound, like `Sized?`
`462`		`- pub default_unbound: Option<Type>`
`463`	`461`	`}`
`464`	`462`
`465`	`463`	`impl Clean<TyParam> for ast::TyParam {`
`@@ -469,7 +467,6 @@ impl Clean<TyParam> for ast::TyParam {`
`469`	`467`	`did: ast::DefId { krate: ast::LOCAL_CRATE, node: self.id },`
`470`	`468`	`bounds: self.bounds.clean(cx),`
`471`	`469`	`default: self.default.clean(cx),`
`472`		`- default_unbound: self.unbound.clean(cx)`
`473`	`470`	`}`
`474`	`471`	`}`
`475`	`472`	`}`
`@@ -478,28 +475,27 @@ impl<'tcx> Clean<TyParam> for ty::TypeParameterDef<'tcx> {`
`478`	`475`	`fn clean(&self, cx: &DocContext) -> TyParam {`
`479`	`476`	`cx.external_typarams.borrow_mut().as_mut().unwrap()`
`480`	`477`	`.insert(self.def_id, self.name.clean(cx));`
`481`		`- let (bounds, default_unbound) = self.bounds.clean(cx);`
	`478`	`+ let bounds = self.bounds.clean(cx);`
`482`	`479`	`TyParam {`
`483`	`480`	`name: self.name.clean(cx),`
`484`	`481`	`did: self.def_id,`
`485`	`482`	`bounds: bounds,`
`486`	`483`	`default: self.default.clean(cx),`
`487`		`- default_unbound: default_unbound`
`488`	`484`	`}`
`489`	`485`	`}`
`490`	`486`	`}`
`491`	`487`
`492`	`488`	`#[deriving(Clone, RustcEncodable, RustcDecodable, PartialEq)]`
`493`	`489`	`pub enum TyParamBound {`
`494`	`490`	`RegionBound(Lifetime),`
`495`		`- TraitBound(PolyTrait)`
	`491`	`+ TraitBound(PolyTrait, ast::TraitBoundModifier)`
`496`	`492`	`}`
`497`	`493`
`498`	`494`	`impl Clean<TyParamBound> for ast::TyParamBound {`
`499`	`495`	`fn clean(&self, cx: &DocContext) -> TyParamBound {`
`500`	`496`	`match *self {`
`501`	`497`	`ast::RegionTyParamBound(lt) => RegionBound(lt.clean(cx)),`
`502`		`- ast::TraitTyParamBound(ref t) => TraitBound(t.clean(cx)),`
	`498`	`+ ast::TraitTyParamBound(ref t, modifier) => TraitBound(t.clean(cx), modifier),`
`503`	`499`	`}`
`504`	`500`	`}`
`505`	`501`	`}`
`@@ -600,7 +596,7 @@ impl Clean<TyParamBound> for ty::BuiltinBound {`
`600`	`596`	`did: did,`
`601`	`597`	`},`
`602`	`598`	`lifetimes: vec![]`
`603`		`- })`
	`599`	`+ }, ast::TraitBoundModifier::None)`
`604`	`600`	`}`
`605`	`601`	`}`
`606`	`602`
`@@ -648,37 +644,20 @@ impl<'tcx> Clean<TyParamBound> for ty::TraitRef<'tcx> {`
`648`	`644`	`TraitBound(PolyTrait {`
`649`	`645`	`trait_: ResolvedPath { path: path, typarams: None, did: self.def_id, },`
`650`	`646`	`lifetimes: late_bounds`
`651`		`- })`
	`647`	`+ }, ast::TraitBoundModifier::None)`
`652`	`648`	`}`
`653`	`649`	`}`
`654`	`650`
`655`		`-// Returns (bounds, default_unbound)`
`656`		`-impl<'tcx> Clean<(Vec<TyParamBound>, Option<Type>)> for ty::ParamBounds<'tcx> {`
`657`		`- fn clean(&self, cx: &DocContext) -> (Vec<TyParamBound>, Option<Type>) {`
	`651`	`+impl<'tcx> Clean<Vec<TyParamBound>> for ty::ParamBounds<'tcx> {`
	`652`	`+ fn clean(&self, cx: &DocContext) -> Vec<TyParamBound> {`
`658`	`653`	`let mut v = Vec::new();`
`659`		`- let mut has_sized_bound = false;`
`660`		`- for b in self.builtin_bounds.iter() {`
`661`		`- if b != ty::BoundSized {`
`662`		`- v.push(b.clean(cx));`
`663`		`- } else {`
`664`		`- has_sized_bound = true;`
`665`		`- }`
`666`		`- }`
`667`	`654`	`for t in self.trait_bounds.iter() {`
`668`	`655`	`v.push(t.clean(cx));`
`669`	`656`	`}`
`670`	`657`	`for r in self.region_bounds.iter().filter_map(\|r\| r.clean(cx)) {`
`671`	`658`	`v.push(RegionBound(r));`
`672`	`659`	`}`
`673`		`- if has_sized_bound {`
`674`		`- (v, None)`
`675`		`- } else {`
`676`		`- let ty = match ty::BoundSized.clean(cx) {`
`677`		`- TraitBound(polyt) => polyt.trait_,`
`678`		`- _ => unreachable!()`
`679`		`- };`
`680`		`- (v, Some(ty))`
`681`		`- }`
	`660`	`+ v`
`682`	`661`	`}`
`683`	`662`	`}`
`684`	`663`
`@@ -689,7 +668,7 @@ impl<'tcx> Clean<Option<Vec<TyParamBound>>> for subst::Substs<'tcx> {`
`689`	`668`	`v.extend(self.types.iter().map(\|t\| TraitBound(PolyTrait {`
`690`	`669`	`trait_: t.clean(cx),`
`691`	`670`	`lifetimes: vec![]`
`692`		`- })));`
	`671`	`+ }, ast::TraitBoundModifier::None)));`
`693`	`672`	`if v.len() > 0 {Some(v)} else {None}`
`694`	`673`	`}`
`695`	`674`	`}`
`@@ -1047,8 +1026,6 @@ pub struct Trait {`
`1047`	`1026`	`pub items: Vec<TraitMethod>,`
`1048`	`1027`	`pub generics: Generics,`
`1049`	`1028`	`pub bounds: Vec<TyParamBound>,`
`1050`		- /// An optional default bound not required for `Self`, like `Sized?`
`1051`		`- pub default_unbound: Option<Type>`
`1052`	`1029`	`}`
`1053`	`1030`
`1054`	`1031`	`impl Clean<Item> for doctree::Trait {`
`@@ -1065,7 +1042,6 @@ impl Clean<Item> for doctree::Trait {`
`1065`	`1042`	`items: self.items.clean(cx),`
`1066`	`1043`	`generics: self.generics.clean(cx),`
`1067`	`1044`	`bounds: self.bounds.clean(cx),`
`1068`		`- default_unbound: self.default_unbound.clean(cx)`
`1069`	`1045`	`}),`
`1070`	`1046`	`}`
`1071`	`1047`	`}`
`@@ -2412,7 +2388,6 @@ impl Clean<Item> for ty::AssociatedType {`
`2412`	`2388`	`},`
`2413`	`2389`	`bounds: vec![],`
`2414`	`2390`	`default: None,`
`2415`		`- default_unbound: None`
`2416`	`2391`	`}),`
`2417`	`2392`	`visibility: None,`
`2418`	`2393`	`def_id: self.def_id,`
Original file line number	Diff line number	Diff line change
`@@ -178,7 +178,6 @@ pub struct Trait {`
`178`	`178`	`pub whence: Span,`
`179`	`179`	`pub vis: ast::Visibility,`
`180`	`180`	`pub stab: Option<attr::Stability>,`
`181`		`- pub default_unbound: Option<ast::TraitRef> // FIXME(tomjakubowski)`
`182`	`181`	`}`
`183`	`182`
`184`	`183`	`pub struct Impl {`
Original file line number	Diff line number	Diff line change
`@@ -97,9 +97,6 @@ impl fmt::Show for clean::Generics {`
`97`	`97`	`if i > 0 {`
`98`	`98`	`try!(f.write(", ".as_bytes()))`
`99`	`99`	`}`
`100`		`- if let Some(ref unbound) = tp.default_unbound {`
`101`		`- try!(write!(f, "{}? ", unbound));`
`102`		`- };`
`103`	`100`	`try!(f.write(tp.name.as_bytes()));`
`104`	`101`
`105`	`102`	`if tp.bounds.len() > 0 {`
`@@ -182,8 +179,12 @@ impl fmt::Show for clean::TyParamBound {`
`182`	`179`	`clean::RegionBound(ref lt) => {`
`183`	`180`	`write!(f, "{}", *lt)`
`184`	`181`	`}`
`185`		`- clean::TraitBound(ref ty) => {`
`186`		`- write!(f, "{}", *ty)`
	`182`	`+ clean::TraitBound(ref ty, modifier) => {`
	`183`	`+ let modifier_str = match modifier {`
	`184`	`+ ast::TraitBoundModifier::None => "",`
	`185`	`+ ast::TraitBoundModifier::Maybe => "?",`
	`186`	`+ };`
	`187`	`+ write!(f, "{}{}", modifier_str, *ty)`
`187`	`188`	`}`
`188`	`189`	`}`
`189`	`190`	`}`
`@@ -458,12 +459,15 @@ impl fmt::Show for clean::Type {`
`458`	`459`	`for bound in decl.bounds.iter() {`
`459`	`460`	`match *bound {`
`460`	`461`	`clean::RegionBound(..) => {}`
`461`		`- clean::TraitBound(ref t) => {`
	`462`	`+ clean::TraitBound(ref t, modifier) => {`
`462`	`463`	`if ret.len() == 0 {`
`463`	`464`	`ret.push_str(": ");`
`464`	`465`	`} else {`
`465`	`466`	`ret.push_str(" + ");`
`466`	`467`	`}`
	`468`	`+ if modifier == ast::TraitBoundModifier::Maybe {`
	`469`	`+ ret.push_str("?");`
	`470`	`+ }`
`467`	`471`	`ret.push_str(format!("{}",`
`468`	`472`	`*t).as_slice());`
`469`	`473`	`}`