rust-lang/rust
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

rustdoc: Fix rendering closures and trait bounds

Browse Source 
Closures did not have their bounds printed at all, nor their lifetimes. Trait
bounds were also printed in angle brackets rather than after a colon with a '+'
inbetween them.

Note that on the current task::spawn [1] documentation page, there is no mention
of a `Send` bound even though it is crucially important!

[1] - http://static.rust-lang.org/doc/master/std/task/fn.task.html
This commit is contained in:
Alex Crichton
2014-04-11 12:45:51 -07:00
parent 4c62ab109b
commit 44e34c24c4
2 changed files with 60 additions and 23 deletions
Download Patch File Download Diff File Expand all files Collapse all files

74
src/librustdoc/html/format.rs
View File

@@ -279,18 +279,17 @@ fn path(w: &mut io::Writer, path: &clean::Path, print_all: bool,
} }
/// Helper to render type parameters /// Helper to render type parameters
fn typarams(w: &mut io::Writer, fn tybounds(w: &mut io::Writer,
typarams: &Option<Vec<clean::TyParamBound> >) -> fmt::Result { typarams: &Option<Vec<clean::TyParamBound> >) -> fmt::Result {
match *typarams { match *typarams {
Some(ref params) => { Some(ref params) => {
try!(write!(w, "&lt;")); try!(write!(w, ":"));
for (i, param) in params.iter().enumerate() { for (i, param) in params.iter().enumerate() {
if i > 0 { if i > 0 {
try!(write!(w, ", ")); try!(write!(w, " + "));
} }
try!(write!(w, "{}", *param)); try!(write!(w, "{}", *param));
} }
try!(write!(w, "&gt;"));
Ok(()) Ok(())
} }
None => Ok(()) None => Ok(())
@@ -308,13 +307,13 @@ impl fmt::Show for clean::Type {
} }
clean::ResolvedPath{id, typarams: ref tp, path: ref path} => { clean::ResolvedPath{id, typarams: ref tp, path: ref path} => {
try!(resolved_path(f.buf, id, path, false)); try!(resolved_path(f.buf, id, path, false));
typarams(f.buf, tp) tybounds(f.buf, tp)
} }
clean::ExternalPath{path: ref path, typarams: ref tp, clean::ExternalPath{path: ref path, typarams: ref tp,
fqn: ref fqn, kind, krate} => { fqn: ref fqn, kind, krate} => {
try!(external_path(f.buf, path, false, fqn.as_slice(), kind, try!(external_path(f.buf, path, false, fqn.as_slice(), kind,
krate)) krate))
typarams(f.buf, tp) tybounds(f.buf, tp)
} }
clean::Self(..) => f.buf.write("Self".as_bytes()), clean::Self(..) => f.buf.write("Self".as_bytes()),
clean::Primitive(prim) => { clean::Primitive(prim) => {
@@ -338,26 +337,59 @@ impl fmt::Show for clean::Type {
f.buf.write(s.as_bytes()) f.buf.write(s.as_bytes())
} }
clean::Closure(ref decl, ref region) => { clean::Closure(ref decl, ref region) => {
let region = match *region { write!(f.buf, "{style}{lifetimes}|{args}|{bounds}\
Some(ref region) => format!("{} ", *region), {arrow, select, yes{ -&gt; {ret}} other{}}",
None => ~"", style = FnStyleSpace(decl.fn_style),
}; lifetimes = if decl.lifetimes.len() == 0 {
~""
write!(f.buf, "{}{}|{}|{arrow, select, yes{ -&gt; {ret}} other{}}", } else {
FnStyleSpace(decl.fn_style), format!("&lt;{:#}&gt;", decl.lifetimes)
region, },
decl.decl.inputs, args = decl.decl.inputs,
arrow = match decl.decl.output { clean::Unit => "no", _ => "yes" }, arrow = match decl.decl.output { clean::Unit => "no", _ => "yes" },
ret = decl.decl.output) ret = decl.decl.output,
// FIXME: where are bounds and lifetimes printed?! bounds = {
let mut ret = StrBuf::new();
match *region {
Some(ref lt) => {
ret.push_str(format!(": {}", *lt));
}
None => {}
}
for bound in decl.bounds.iter() {
match *bound {
clean::RegionBound => {}
clean::TraitBound(ref t) => {
if ret.len() == 0 {
ret.push_str(": ");
} else {
ret.push_str(" + ");
}
ret.push_str(format!("{}", *t));
}
}
}
ret.into_owned()
})
} }
clean::Proc(ref decl) => { clean::Proc(ref decl) => {
write!(f.buf, "{}proc({}){arrow, select, yes{ -&gt; {ret}} other{}}", write!(f.buf, "{style}{lifetimes}proc({args}){bounds}\
FnStyleSpace(decl.fn_style), {arrow, select, yes{ -&gt; {ret}} other{}}",
decl.decl.inputs, style = FnStyleSpace(decl.fn_style),
lifetimes = if decl.lifetimes.len() == 0 {
~""
} else {
format!("&lt;{:#}&gt;", decl.lifetimes)
},
args = decl.decl.inputs,
bounds = if decl.bounds.len() == 0 {
~""
} else {
let mut m = decl.bounds.iter().map(|s| s.to_str());
": " + m.collect::<~[~str]>().connect(" + ")
},
arrow = match decl.decl.output { clean::Unit => "no", _ => "yes" }, arrow = match decl.decl.output { clean::Unit => "no", _ => "yes" },
ret = decl.decl.output) ret = decl.decl.output)
// FIXME: where are bounds and lifetimes printed?!
} }
clean::BareFunction(ref decl) => { clean::BareFunction(ref decl) => {
write!(f.buf, "{}{}fn{}{}", write!(f.buf, "{}{}fn{}{}",

9
src/libstd/slice.rs
View File

@@ -2601,7 +2601,9 @@ impl<A: Clone> Clone for ~[A] {
impl<'a, T: fmt::Show> fmt::Show for &'a [T] { impl<'a, T: fmt::Show> fmt::Show for &'a [T] {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
try!(write!(f.buf, "[")); if f.flags & (1 << (fmt::parse::FlagAlternate as uint)) == 0 {
try!(write!(f.buf, "["));
}
let mut is_first = true; let mut is_first = true;
for x in self.iter() { for x in self.iter() {
if is_first { if is_first {
@@ -2611,7 +2613,10 @@ impl<'a, T: fmt::Show> fmt::Show for &'a [T] {
} }
try!(write!(f.buf, "{}", *x)) try!(write!(f.buf, "{}", *x))
} }
write!(f.buf, "]") if f.flags & (1 << (fmt::parse::FlagAlternate as uint)) == 0 {
try!(write!(f.buf, "]"));
}
Ok(())
} }
} }