#[derive(Copy, Clone)]
pub struct RawMutableSpace(pub clean::Mutability);
/// Wrapper struct for emitting a where clause from Generics.
-pub struct WhereClause<'a>(pub &'a clean::Generics);
+pub struct WhereClause<'a>(pub &'a clean::Generics, pub String);
/// Wrapper struct for emitting type parameter bounds.
pub struct TyParamBounds<'a>(pub &'a [clean::TyParamBound]);
/// Wrapper struct for emitting a comma-separated list of items
impl<'a> fmt::Display for WhereClause<'a> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- let &WhereClause(gens) = self;
+ let &WhereClause(gens, ref pad) = self;
if gens.where_predicates.is_empty() {
return Ok(());
}
if !f.alternate() {
clause.push_str("</span>");
let plain = format!("{:#}", self);
- if plain.len() > 80 {
- let padding = repeat(" ").take(8).collect::<String>();
+ if plain.len() + pad.len() > 80 {
+ let padding = repeat(" ").take(pad.len() + 6).collect::<String>();
clause = clause.replace("<br>", &format!("<br>{}", padding));
} else {
clause = clause.replace("<br>", " ");
}
fn fmt_impl(i: &clean::Impl, f: &mut fmt::Formatter, link_trait: bool) -> fmt::Result {
+ let mut plain = String::new();
+
if f.alternate() {
write!(f, "impl{:#} ", i.generics)?;
} else {
write!(f, "impl{} ", i.generics)?;
}
+ plain.push_str(&format!("impl{:#} ", i.generics));
+
if let Some(ref ty) = i.trait_ {
- write!(f, "{}",
- if i.polarity == Some(clean::ImplPolarity::Negative) { "!" } else { "" })?;
+ if i.polarity == Some(clean::ImplPolarity::Negative) {
+ write!(f, "!")?;
+ plain.push_str("!");
+ }
+
if link_trait {
fmt::Display::fmt(ty, f)?;
+ plain.push_str(&format!("{:#}", ty));
} else {
match *ty {
clean::ResolvedPath{ typarams: None, ref path, is_generic: false, .. } => {
let last = path.segments.last().unwrap();
fmt::Display::fmt(&last.name, f)?;
fmt::Display::fmt(&last.params, f)?;
+ plain.push_str(&format!("{:#}{:#}", last.name, last.params));
}
_ => unreachable!(),
}
}
write!(f, " for ")?;
+ plain.push_str(" for ");
}
+
fmt::Display::fmt(&i.for_, f)?;
- fmt::Display::fmt(&WhereClause(&i.generics), f)?;
+ plain.push_str(&format!("{:#}", i.for_));
+
+ let pad = repeat(" ").take(plain.len() + 1).collect::<String>();
+ fmt::Display::fmt(&WhereClause(&i.generics, pad), f)?;
Ok(())
}
} else {
output = output.replace("<br>", "");
}
- write!(f, "{}", output)
+ if f.alternate() {
+ write!(f, "{}", output.replace("<br>", "\n"))
+ } else {
+ write!(f, "{}", output)
+ }
}
}
abi = AbiSpace(f.abi),
name = it.name.as_ref().unwrap(),
generics = f.generics,
- where_clause = WhereClause(&f.generics),
+ where_clause = WhereClause(&f.generics, " ".to_string()),
decl = Method(&f.decl, &indent))?;
document(w, cx, it)
}
fn item_trait(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
t: &clean::Trait) -> fmt::Result {
let mut bounds = String::new();
+ let mut bounds_plain = String::new();
if !t.bounds.is_empty() {
if !bounds.is_empty() {
bounds.push(' ');
+ bounds_plain.push(' ');
}
bounds.push_str(": ");
+ bounds_plain.push_str(": ");
for (i, p) in t.bounds.iter().enumerate() {
- if i > 0 { bounds.push_str(" + "); }
+ if i > 0 {
+ bounds.push_str(" + ");
+ bounds_plain.push_str(" + ");
+ }
bounds.push_str(&format!("{}", *p));
+ bounds_plain.push_str(&format!("{:#}", *p));
}
}
+ // Where clauses in traits are indented nine spaces, per rustdoc.css
+ let indent = " ".to_string();
+
// Output the trait definition
write!(w, "<pre class='rust trait'>{}{}trait {}{}{}{} ",
VisSpace(&it.visibility),
it.name.as_ref().unwrap(),
t.generics,
bounds,
- WhereClause(&t.generics))?;
+ WhereClause(&t.generics, indent))?;
let types = t.items.iter().filter(|m| m.is_associated_type()).collect::<Vec<_>>();
let consts = t.items.iter().filter(|m| m.is_associated_const()).collect::<Vec<_>>();
write!(w, "{{\n")?;
for t in &types {
write!(w, " ")?;
- render_assoc_item(w, t, AssocItemLink::Anchor(None))?;
+ render_assoc_item(w, t, AssocItemLink::Anchor(None), ItemType::Trait)?;
write!(w, ";\n")?;
}
if !types.is_empty() && !consts.is_empty() {
}
for t in &consts {
write!(w, " ")?;
- render_assoc_item(w, t, AssocItemLink::Anchor(None))?;
+ render_assoc_item(w, t, AssocItemLink::Anchor(None), ItemType::Trait)?;
write!(w, ";\n")?;
}
if !consts.is_empty() && !required.is_empty() {
}
for m in &required {
write!(w, " ")?;
- render_assoc_item(w, m, AssocItemLink::Anchor(None))?;
+ render_assoc_item(w, m, AssocItemLink::Anchor(None), ItemType::Trait)?;
write!(w, ";\n")?;
}
if !required.is_empty() && !provided.is_empty() {
}
for m in &provided {
write!(w, " ")?;
- render_assoc_item(w, m, AssocItemLink::Anchor(None))?;
+ render_assoc_item(w, m, AssocItemLink::Anchor(None), ItemType::Trait)?;
write!(w, " {{ ... }}\n")?;
}
write!(w, "}}")?;
id = id,
stab = m.stability_class(),
ns_id = ns_id)?;
- render_assoc_item(w, m, AssocItemLink::Anchor(Some(&id)))?;
+ render_assoc_item(w, m, AssocItemLink::Anchor(Some(&id)), ItemType::Impl)?;
write!(w, "</code>")?;
render_stability_since(w, m, t)?;
write!(w, "</span></h3>")?;
fn render_assoc_item(w: &mut fmt::Formatter,
item: &clean::Item,
- link: AssocItemLink) -> fmt::Result {
+ link: AssocItemLink,
+ parent: ItemType) -> fmt::Result {
fn method(w: &mut fmt::Formatter,
meth: &clean::Item,
unsafety: hir::Unsafety,
abi: abi::Abi,
g: &clean::Generics,
d: &clean::FnDecl,
- link: AssocItemLink)
+ link: AssocItemLink,
+ parent: ItemType)
-> fmt::Result {
let name = meth.name.as_ref().unwrap();
let anchor = format!("#{}.{}", meth.type_(), name);
AbiSpace(abi),
name,
*g);
- let indent = repeat(" ").take(prefix.len()).collect::<String>();
+ let mut indent = repeat(" ").take(prefix.len()).collect::<String>();
+ let where_indent = if parent == ItemType::Trait {
+ indent += " ";
+ " ".to_string()
+ } else if parent == ItemType::Impl {
+ " ".to_string()
+ } else {
+ let prefix = prefix + &format!("{:#}", Method(d, &indent));
+ let prefix = prefix.lines().last().unwrap();
+ repeat(" ").take(prefix.len() + 1).collect::<String>()
+ };
write!(w, "{}{}{}fn <a href='{href}' class='fnname'>{name}</a>\
{generics}{decl}{where_clause}",
ConstnessSpace(vis_constness),
name = name,
generics = *g,
decl = Method(d, &indent),
- where_clause = WhereClause(g))
+ where_clause = WhereClause(g, where_indent))
}
match item.inner {
clean::StrippedItem(..) => Ok(()),
clean::TyMethodItem(ref m) => {
method(w, item, m.unsafety, hir::Constness::NotConst,
- m.abi, &m.generics, &m.decl, link)
+ m.abi, &m.generics, &m.decl, link, parent)
}
clean::MethodItem(ref m) => {
method(w, item, m.unsafety, m.constness,
- m.abi, &m.generics, &m.decl,
- link)
+ m.abi, &m.generics, &m.decl, link, parent)
}
clean::AssociatedConstItem(ref ty, ref default) => {
assoc_const(w, item, ty, default.as_ref(), link)
e: &clean::Enum) -> fmt::Result {
write!(w, "<pre class='rust enum'>")?;
render_attributes(w, it)?;
+ let padding = format!("{}enum {}{:#} ",
+ VisSpace(&it.visibility),
+ it.name.as_ref().unwrap(),
+ e.generics);
write!(w, "{}enum {}{}{}",
VisSpace(&it.visibility),
it.name.as_ref().unwrap(),
e.generics,
- WhereClause(&e.generics))?;
+ WhereClause(&e.generics, padding))?;
if e.variants.is_empty() && !e.variants_stripped {
write!(w, " {{}}")?;
} else {
fields: &[clean::Item],
tab: &str,
structhead: bool) -> fmt::Result {
+ let mut plain = String::new();
write!(w, "{}{}{}",
VisSpace(&it.visibility),
if structhead {"struct "} else {""},
it.name.as_ref().unwrap())?;
+ plain.push_str(&format!("{}{}{}",
+ VisSpace(&it.visibility),
+ if structhead {"struct "} else {""},
+ it.name.as_ref().unwrap()));
if let Some(g) = g {
+ plain.push_str(&format!("{:#}", g));
write!(w, "{}", g)?
}
match ty {
doctree::Plain => {
if let Some(g) = g {
- write!(w, "{}", WhereClause(g))?
+ let pad = repeat(" ").take(plain.len() + 1).collect::<String>();
+ write!(w, "{}", WhereClause(g, pad))?
}
let mut has_visible_fields = false;
write!(w, " {{")?;
}
doctree::Tuple => {
write!(w, "(")?;
+ plain.push_str("(");
for (i, field) in fields.iter().enumerate() {
if i > 0 {
write!(w, ", ")?;
+ plain.push_str(", ");
}
match field.inner {
clean::StrippedItem(box clean::StructFieldItem(..)) => {
+ plain.push_str("_");
write!(w, "_")?
}
clean::StructFieldItem(ref ty) => {
+ plain.push_str(&format!("{}{:#}", VisSpace(&field.visibility), *ty));
write!(w, "{}{}", VisSpace(&field.visibility), *ty)?
}
_ => unreachable!()
}
}
write!(w, ")")?;
+ plain.push_str(")");
if let Some(g) = g {
- write!(w, "{}", WhereClause(g))?
+ let pad = repeat(" ").take(plain.len() + 1).collect::<String>();
+ write!(w, "{}", WhereClause(g, pad))?
}
write!(w, ";")?;
}
doctree::Unit => {
// Needed for PhantomData.
if let Some(g) = g {
- write!(w, "{}", WhereClause(g))?
+ let pad = repeat(" ").take(plain.len() + 1).collect::<String>();
+ write!(w, "{}", WhereClause(g, pad))?
}
write!(w, ";")?;
}
fields: &[clean::Item],
tab: &str,
structhead: bool) -> fmt::Result {
+ let mut plain = String::new();
write!(w, "{}{}{}",
VisSpace(&it.visibility),
if structhead {"union "} else {""},
it.name.as_ref().unwrap())?;
+ plain.push_str(&format!("{}{}{}",
+ VisSpace(&it.visibility),
+ if structhead {"union "} else {""},
+ it.name.as_ref().unwrap()));
if let Some(g) = g {
write!(w, "{}", g)?;
- write!(w, "{}", WhereClause(g))?;
+ plain.push_str(&format!("{:#}", g));
+ let pad = repeat(" ").take(plain.len() + 1).collect::<String>();
+ write!(w, "{}", WhereClause(g, pad))?;
}
write!(w, " {{\n{}", tab)?;
write!(w, "<h4 id='{}' class='{}'>", id, item_type)?;
write!(w, "<span id='{}' class='invisible'>", ns_id)?;
write!(w, "<code>")?;
- render_assoc_item(w, item, link.anchor(&id))?;
+ render_assoc_item(w, item, link.anchor(&id), ItemType::Impl)?;
write!(w, "</code>")?;
render_stability_since_raw(w, item.stable_since(), outer_version)?;
write!(w, "</span></h4>\n")?;
fn item_typedef(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
t: &clean::Typedef) -> fmt::Result {
+ let indent = format!("type {}{:#} ", it.name.as_ref().unwrap(), t.generics);
+ let indent = repeat(" ").take(indent.len()).collect::<String>();
write!(w, "<pre class='rust typedef'>type {}{}{where_clause} = {type_};</pre>",
it.name.as_ref().unwrap(),
t.generics,
- where_clause = WhereClause(&t.generics),
+ where_clause = WhereClause(&t.generics, indent),
type_ = t.type_)?;
document(w, cx, it)