#[derive(Copy, Clone)]
pub struct ConstnessSpace(pub hir::Constness);
/// Wrapper struct for properly emitting a method declaration.
-pub struct Method<'a>(pub &'a clean::FnDecl, pub &'a str);
+pub struct Method<'a>(pub &'a clean::FnDecl, pub usize);
/// Similar to VisSpace, but used for mutability
#[derive(Copy, Clone)]
pub struct MutableSpace(pub clean::Mutability);
#[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 String);
+pub struct WhereClause<'a>(pub &'a clean::Generics, pub usize);
/// 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, ref pad) = self;
+ let &WhereClause(gens, pad) = self;
if gens.where_predicates.is_empty() {
return Ok(());
}
if !f.alternate() {
clause.push_str("</span>");
let plain = format!("{:#}", self);
- if plain.len() + pad.len() > 80 {
+ if plain.len() > 80 {
//break it onto its own line regardless, but make sure method impls and trait
//blocks keep their fixed padding (2 and 9, respectively)
- let padding = if pad.len() > 10 {
+ let padding = if pad > 10 {
clause = clause.replace("class='where'", "class='where fmt-newline'");
repeat(" ").take(8).collect::<String>()
} else {
- repeat(" ").take(pad.len() + 6).collect::<String>()
+ repeat(" ").take(pad + 6).collect::<String>()
};
clause = clause.replace("<br>", &format!("<br>{}", padding));
} else {
fmt::Display::fmt(&i.for_, f)?;
plain.push_str(&format!("{:#}", i.for_));
- let pad = repeat(" ").take(plain.len() + 1).collect::<String>();
- fmt::Display::fmt(&WhereClause(&i.generics, pad), f)?;
+ fmt::Display::fmt(&WhereClause(&i.generics, plain.len() + 1), f)?;
Ok(())
}
let mut output: String;
let plain: String;
+ let pad = repeat(" ").take(indent).collect::<String>();
if arrow.is_empty() {
output = format!("({})", args);
- plain = format!("{}({})", indent.replace(" ", " "), args_plain);
+ plain = format!("{}({})", pad, args_plain);
} else {
output = format!("({args})<br>{arrow}", args = args, arrow = arrow);
- plain = format!("{indent}({args}){arrow}",
- indent = indent.replace(" ", " "),
+ plain = format!("{pad}({args}){arrow}",
+ pad = pad,
args = args_plain,
arrow = arrow_plain);
}
if plain.len() > 80 {
- let pad = format!("<br>{}", indent);
+ let pad = repeat(" ").take(indent).collect::<String>();
+ let pad = format!("<br>{}", pad);
output = output.replace("<br>", &pad);
} else {
output = output.replace("<br>", "");
UnstableFeatures::Allow => f.constness,
_ => hir::Constness::NotConst
};
- let prefix = format!("{}{}{}{:#}fn {}{:#}",
+ let indent = format!("{}{}{}{:#}fn {}{:#}",
VisSpace(&it.visibility),
ConstnessSpace(vis_constness),
UnsafetySpace(f.unsafety),
AbiSpace(f.abi),
it.name.as_ref().unwrap(),
- f.generics);
- let indent = repeat(" ").take(prefix.len()).collect::<String>();
+ f.generics).len();
write!(w, "<pre class='rust fn'>{vis}{constness}{unsafety}{abi}fn \
{name}{generics}{decl}{where_clause}</pre>",
vis = VisSpace(&it.visibility),
abi = AbiSpace(f.abi),
name = it.name.as_ref().unwrap(),
generics = f.generics,
- where_clause = WhereClause(&f.generics, " ".to_string()),
- decl = Method(&f.decl, &indent))?;
+ where_clause = WhereClause(&f.generics, 2),
+ decl = Method(&f.decl, indent))?;
document(w, cx, it)
}
}
}
- // 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, indent))?;
+ // Where clauses in traits are indented nine spaces, per rustdoc.css
+ WhereClause(&t.generics, 9))?;
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<_>>();
AbiSpace(abi),
name,
*g);
- let mut indent = repeat(" ").take(prefix.len()).collect::<String>();
+ let mut indent = prefix.len();
let where_indent = if parent == ItemType::Trait {
- indent += " ";
- " ".to_string()
+ indent += 4;
+ 8
} else if parent == ItemType::Impl {
- " ".to_string()
+ 2
} else {
- let prefix = prefix + &format!("{:#}", Method(d, &indent));
- let prefix = prefix.lines().last().unwrap();
- repeat(" ").take(prefix.len() + 1).collect::<String>()
+ let prefix = prefix + &format!("{:#}", Method(d, indent));
+ prefix.lines().last().unwrap().len() + 1
};
write!(w, "{}{}{}fn <a href='{href}' class='fnname'>{name}</a>\
{generics}{decl}{where_clause}",
href = href,
name = name,
generics = *g,
- decl = Method(d, &indent),
+ decl = Method(d, indent),
where_clause = WhereClause(g, where_indent))
}
match item.inner {
let padding = format!("{}enum {}{:#} ",
VisSpace(&it.visibility),
it.name.as_ref().unwrap(),
- e.generics);
+ e.generics).len();
write!(w, "{}enum {}{}{}",
VisSpace(&it.visibility),
it.name.as_ref().unwrap(),
match ty {
doctree::Plain => {
if let Some(g) = g {
- let pad = repeat(" ").take(plain.len() + 1).collect::<String>();
- write!(w, "{}", WhereClause(g, pad))?
+ write!(w, "{}", WhereClause(g, plain.len() + 1))?
}
let mut has_visible_fields = false;
write!(w, " {{")?;
write!(w, ")")?;
plain.push_str(")");
if let Some(g) = g {
- let pad = repeat(" ").take(plain.len() + 1).collect::<String>();
- write!(w, "{}", WhereClause(g, pad))?
+ write!(w, "{}", WhereClause(g, plain.len() + 1))?
}
write!(w, ";")?;
}
doctree::Unit => {
// Needed for PhantomData.
if let Some(g) = g {
- let pad = repeat(" ").take(plain.len() + 1).collect::<String>();
- write!(w, "{}", WhereClause(g, pad))?
+ write!(w, "{}", WhereClause(g, plain.len() + 1))?
}
write!(w, ";")?;
}
if let Some(g) = g {
write!(w, "{}", g)?;
plain.push_str(&format!("{:#}", g));
- let pad = repeat(" ").take(plain.len() + 1).collect::<String>();
- write!(w, "{}", WhereClause(g, pad))?;
+ write!(w, "{}", WhereClause(g, plain.len() + 1))?;
}
write!(w, " {{\n{}", tab)?;
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>();
+ let indent = format!("type {}{:#} ", it.name.as_ref().unwrap(), t.generics).len();
write!(w, "<pre class='rust typedef'>type {}{}{where_clause} = {type_};</pre>",
it.name.as_ref().unwrap(),
t.generics,