Skip to content

Commit 80bff6b

Browse files
rustdoc: format where clauses like rust-lang/style-team#38
1 parent 8206d0c commit 80bff6b

File tree

3 files changed

+55
-81
lines changed

3 files changed

+55
-81
lines changed

src/librustdoc/html/format.rs

Lines changed: 29 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -49,14 +49,19 @@ pub struct MutableSpace(pub clean::Mutability);
4949
/// Similar to VisSpace, but used for mutability
5050
#[derive(Copy, Clone)]
5151
pub struct RawMutableSpace(pub clean::Mutability);
52-
/// Wrapper struct for emitting a where clause from Generics.
53-
pub struct WhereClause<'a>(pub &'a clean::Generics, pub usize);
5452
/// Wrapper struct for emitting type parameter bounds.
5553
pub struct TyParamBounds<'a>(pub &'a [clean::TyParamBound]);
5654
/// Wrapper struct for emitting a comma-separated list of items
5755
pub struct CommaSep<'a, T: 'a>(pub &'a [T]);
5856
pub struct AbiSpace(pub Abi);
5957

58+
/// Wrapper struct for emitting a where clause from Generics.
59+
pub struct WhereClause<'a>{
60+
pub gens: &'a clean::Generics,
61+
pub indent: usize,
62+
pub end_newline: bool,
63+
}
64+
6065
pub struct HRef<'a> {
6166
pub did: DefId,
6267
pub text: &'a str,
@@ -167,24 +172,27 @@ impl fmt::Display for clean::Generics {
167172

168173
impl<'a> fmt::Display for WhereClause<'a> {
169174
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
170-
let &WhereClause(gens, pad) = self;
175+
let &WhereClause{ gens, indent, end_newline } = self;
171176
if gens.where_predicates.is_empty() {
172177
return Ok(());
173178
}
174179
let mut clause = String::new();
175180
if f.alternate() {
176-
clause.push_str(" where ");
181+
clause.push_str(" where");
177182
} else {
178-
clause.push_str(" <span class=\"where fmt-newline\">where ");
183+
if end_newline {
184+
clause.push_str("<span class=\"where fmt-newline\">where");
185+
} else {
186+
clause.push_str("<span class=\"where\">where");
187+
}
179188
}
180189
for (i, pred) in gens.where_predicates.iter().enumerate() {
181-
if i > 0 {
182-
if f.alternate() {
183-
clause.push_str(", ");
184-
} else {
185-
clause.push_str(",<br>");
186-
}
190+
if f.alternate() {
191+
clause.push(' ');
192+
} else {
193+
clause.push_str("<br>");
187194
}
195+
188196
match pred {
189197
&clean::WherePredicate::BoundPredicate { ref ty, ref bounds } => {
190198
let bounds = bounds;
@@ -213,21 +221,18 @@ impl<'a> fmt::Display for WhereClause<'a> {
213221
}
214222
}
215223
}
224+
225+
if i < gens.where_predicates.len() - 1 || end_newline {
226+
clause.push(',');
227+
}
216228
}
217229
if !f.alternate() {
218230
clause.push_str("</span>");
219-
let plain = format!("{:#}", self);
220-
if plain.len() + pad > 80 {
221-
// break it onto its own line regardless, but make sure method impls and trait
222-
// blocks keep their fixed padding (2 and 9, respectively)
223-
let padding = if pad > 10 {
224-
repeat("&nbsp;").take(8).collect::<String>()
225-
} else {
226-
repeat("&nbsp;").take(pad + 6).collect::<String>()
227-
};
228-
clause = clause.replace("<br>", &format!("<br>{}", padding));
229-
} else {
230-
clause = clause.replace("<br>", " ");
231+
let padding = repeat("&nbsp;").take(indent + 4).collect::<String>();
232+
clause = clause.replace("<br>", &format!("<br>{}", padding));
233+
clause.insert_str(0, &repeat("&nbsp;").take(indent).collect::<String>());
234+
if !end_newline {
235+
clause.insert_str(0, "<br>");
231236
}
232237
}
233238
write!(f, "{}", clause)
@@ -838,43 +843,35 @@ fn fmt_impl(i: &clean::Impl,
838843
f: &mut fmt::Formatter,
839844
link_trait: bool,
840845
use_absolute: bool) -> fmt::Result {
841-
let mut plain = String::new();
842-
843846
if f.alternate() {
844847
write!(f, "impl{:#} ", i.generics)?;
845848
} else {
846849
write!(f, "impl{} ", i.generics)?;
847850
}
848-
plain.push_str(&format!("impl{:#} ", i.generics));
849851

850852
if let Some(ref ty) = i.trait_ {
851853
if i.polarity == Some(clean::ImplPolarity::Negative) {
852854
write!(f, "!")?;
853-
plain.push_str("!");
854855
}
855856

856857
if link_trait {
857858
fmt::Display::fmt(ty, f)?;
858-
plain.push_str(&format!("{:#}", ty));
859859
} else {
860860
match *ty {
861861
clean::ResolvedPath { typarams: None, ref path, is_generic: false, .. } => {
862862
let last = path.segments.last().unwrap();
863863
fmt::Display::fmt(&last.name, f)?;
864864
fmt::Display::fmt(&last.params, f)?;
865-
plain.push_str(&format!("{:#}{:#}", last.name, last.params));
866865
}
867866
_ => unreachable!(),
868867
}
869868
}
870869
write!(f, " for ")?;
871-
plain.push_str(" for ");
872870
}
873871

874872
fmt_type(&i.for_, f, use_absolute, true)?;
875-
plain.push_str(&format!("{:#}", i.for_));
876873

877-
fmt::Display::fmt(&WhereClause(&i.generics, plain.len() + 1), f)?;
874+
fmt::Display::fmt(&WhereClause{ gens: &i.generics, indent: 0, end_newline: true }, f)?;
878875
Ok(())
879876
}
880877

src/librustdoc/html/render.rs

Lines changed: 25 additions & 37 deletions
Original file line numberDiff line numberDiff line change
@@ -2012,7 +2012,7 @@ fn item_function(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
20122012
abi = AbiSpace(f.abi),
20132013
name = it.name.as_ref().unwrap(),
20142014
generics = f.generics,
2015-
where_clause = WhereClause(&f.generics, 2),
2015+
where_clause = WhereClause { gens: &f.generics, indent: 0, end_newline: true },
20162016
decl = Method(&f.decl, indent))?;
20172017
document(w, cx, it)
20182018
}
@@ -2047,8 +2047,7 @@ fn item_trait(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
20472047
it.name.as_ref().unwrap(),
20482048
t.generics,
20492049
bounds,
2050-
// Where clauses in traits are indented nine spaces, per rustdoc.css
2051-
WhereClause(&t.generics, 9))?;
2050+
WhereClause { gens: &t.generics, indent: 0, end_newline: true })?;
20522051

20532052
let types = t.items.iter().filter(|m| m.is_associated_type()).collect::<Vec<_>>();
20542053
let consts = t.items.iter().filter(|m| m.is_associated_const()).collect::<Vec<_>>();
@@ -2087,7 +2086,14 @@ fn item_trait(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
20872086
for m in &provided {
20882087
write!(w, " ")?;
20892088
render_assoc_item(w, m, AssocItemLink::Anchor(None), ItemType::Trait)?;
2090-
write!(w, " {{ ... }}\n")?;
2089+
match m.inner {
2090+
clean::MethodItem(ref inner) if !inner.generics.where_predicates.is_empty() => {
2091+
write!(w, ",\n {{ ... }}\n")?;
2092+
},
2093+
_ => {
2094+
write!(w, " {{ ... }}\n")?;
2095+
},
2096+
}
20912097
}
20922098
write!(w, "}}")?;
20932099
}
@@ -2327,14 +2333,14 @@ fn render_assoc_item(w: &mut fmt::Formatter,
23272333
name,
23282334
*g);
23292335
let mut indent = prefix.len();
2330-
let where_indent = if parent == ItemType::Trait {
2336+
let (where_indent, end_newline) = if parent == ItemType::Trait {
23312337
indent += 4;
2332-
8
2338+
(4, false)
23332339
} else if parent == ItemType::Impl {
2334-
2
2340+
(0, true)
23352341
} else {
23362342
let prefix = prefix + &format!("{:#}", Method(d, indent));
2337-
prefix.lines().last().unwrap().len() + 1
2343+
(prefix.lines().last().unwrap().len() + 1, true)
23382344
};
23392345
write!(w, "{}{}{}fn <a href='{href}' class='fnname'>{name}</a>\
23402346
{generics}{decl}{where_clause}",
@@ -2345,7 +2351,11 @@ fn render_assoc_item(w: &mut fmt::Formatter,
23452351
name = name,
23462352
generics = *g,
23472353
decl = Method(d, indent),
2348-
where_clause = WhereClause(g, where_indent))
2354+
where_clause = WhereClause {
2355+
gens: g,
2356+
indent: where_indent,
2357+
end_newline: end_newline,
2358+
})
23492359
}
23502360
match item.inner {
23512361
clean::StrippedItem(..) => Ok(()),
@@ -2458,15 +2468,11 @@ fn item_enum(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
24582468
e: &clean::Enum) -> fmt::Result {
24592469
write!(w, "<pre class='rust enum'>")?;
24602470
render_attributes(w, it)?;
2461-
let padding = format!("{}enum {}{:#} ",
2462-
VisSpace(&it.visibility),
2463-
it.name.as_ref().unwrap(),
2464-
e.generics).len();
24652471
write!(w, "{}enum {}{}{}",
24662472
VisSpace(&it.visibility),
24672473
it.name.as_ref().unwrap(),
24682474
e.generics,
2469-
WhereClause(&e.generics, padding))?;
2475+
WhereClause { gens: &e.generics, indent: 0, end_newline: true })?;
24702476
if e.variants.is_empty() && !e.variants_stripped {
24712477
write!(w, " {{}}")?;
24722478
} else {
@@ -2640,23 +2646,17 @@ fn render_struct(w: &mut fmt::Formatter, it: &clean::Item,
26402646
fields: &[clean::Item],
26412647
tab: &str,
26422648
structhead: bool) -> fmt::Result {
2643-
let mut plain = String::new();
26442649
write!(w, "{}{}{}",
26452650
VisSpace(&it.visibility),
26462651
if structhead {"struct "} else {""},
26472652
it.name.as_ref().unwrap())?;
2648-
plain.push_str(&format!("{}{}{}",
2649-
VisSpace(&it.visibility),
2650-
if structhead {"struct "} else {""},
2651-
it.name.as_ref().unwrap()));
26522653
if let Some(g) = g {
2653-
plain.push_str(&format!("{:#}", g));
26542654
write!(w, "{}", g)?
26552655
}
26562656
match ty {
26572657
doctree::Plain => {
26582658
if let Some(g) = g {
2659-
write!(w, "{}", WhereClause(g, plain.len() + 1))?
2659+
write!(w, "{}", WhereClause { gens: g, indent: 0, end_newline: true })?
26602660
}
26612661
let mut has_visible_fields = false;
26622662
write!(w, " {{")?;
@@ -2685,35 +2685,30 @@ fn render_struct(w: &mut fmt::Formatter, it: &clean::Item,
26852685
}
26862686
doctree::Tuple => {
26872687
write!(w, "(")?;
2688-
plain.push_str("(");
26892688
for (i, field) in fields.iter().enumerate() {
26902689
if i > 0 {
26912690
write!(w, ", ")?;
2692-
plain.push_str(", ");
26932691
}
26942692
match field.inner {
26952693
clean::StrippedItem(box clean::StructFieldItem(..)) => {
2696-
plain.push_str("_");
26972694
write!(w, "_")?
26982695
}
26992696
clean::StructFieldItem(ref ty) => {
2700-
plain.push_str(&format!("{}{:#}", VisSpace(&field.visibility), *ty));
27012697
write!(w, "{}{}", VisSpace(&field.visibility), *ty)?
27022698
}
27032699
_ => unreachable!()
27042700
}
27052701
}
27062702
write!(w, ")")?;
2707-
plain.push_str(")");
27082703
if let Some(g) = g {
2709-
write!(w, "{}", WhereClause(g, plain.len() + 1))?
2704+
write!(w, "{}", WhereClause { gens: g, indent: 0, end_newline: true })?
27102705
}
27112706
write!(w, ";")?;
27122707
}
27132708
doctree::Unit => {
27142709
// Needed for PhantomData.
27152710
if let Some(g) = g {
2716-
write!(w, "{}", WhereClause(g, plain.len() + 1))?
2711+
write!(w, "{}", WhereClause { gens: g, indent: 0, end_newline: true })?
27172712
}
27182713
write!(w, ";")?;
27192714
}
@@ -2726,19 +2721,13 @@ fn render_union(w: &mut fmt::Formatter, it: &clean::Item,
27262721
fields: &[clean::Item],
27272722
tab: &str,
27282723
structhead: bool) -> fmt::Result {
2729-
let mut plain = String::new();
27302724
write!(w, "{}{}{}",
27312725
VisSpace(&it.visibility),
27322726
if structhead {"union "} else {""},
27332727
it.name.as_ref().unwrap())?;
2734-
plain.push_str(&format!("{}{}{}",
2735-
VisSpace(&it.visibility),
2736-
if structhead {"union "} else {""},
2737-
it.name.as_ref().unwrap()));
27382728
if let Some(g) = g {
27392729
write!(w, "{}", g)?;
2740-
plain.push_str(&format!("{:#}", g));
2741-
write!(w, "{}", WhereClause(g, plain.len() + 1))?;
2730+
write!(w, "{}", WhereClause { gens: g, indent: 0, end_newline: true })?;
27422731
}
27432732

27442733
write!(w, " {{\n{}", tab)?;
@@ -3037,13 +3026,12 @@ fn render_impl(w: &mut fmt::Formatter, cx: &Context, i: &Impl, link: AssocItemLi
30373026

30383027
fn item_typedef(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
30393028
t: &clean::Typedef) -> fmt::Result {
3040-
let indent = format!("type {}{:#} ", it.name.as_ref().unwrap(), t.generics).len();
30413029
write!(w, "<pre class='rust typedef'>")?;
30423030
render_attributes(w, it)?;
30433031
write!(w, "type {}{}{where_clause} = {type_};</pre>",
30443032
it.name.as_ref().unwrap(),
30453033
t.generics,
3046-
where_clause = WhereClause(&t.generics, indent),
3034+
where_clause = WhereClause { gens: &t.generics, indent: 0, end_newline: true },
30473035
type_ = t.type_)?;
30483036

30493037
document(w, cx, it)

src/librustdoc/html/static/rustdoc.css

Lines changed: 1 addition & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -379,12 +379,6 @@ h4 > code, h3 > code, .invisible > code {
379379
.content .where.fmt-newline {
380380
display: block;
381381
}
382-
/* Bit of whitespace to indent it */
383-
.content .method .where::before,
384-
.content .fn .where::before,
385-
.content .where.fmt-newline::before {
386-
content: ' ';
387-
}
388382

389383
.content .methods > div { margin-left: 40px; }
390384

@@ -399,11 +393,6 @@ h4 > code, h3 > code, .invisible > code {
399393
font-size: 90%;
400394
}
401395

402-
/* Shift where in trait listing down a line */
403-
pre.trait .where::before {
404-
content: '\a ';
405-
}
406-
407396
nav {
408397
border-bottom: 1px solid;
409398
padding-bottom: 10px;
@@ -772,4 +761,4 @@ span.since {
772761
nav.sub, .content .out-of-band, .collapse-toggle {
773762
display: none;
774763
}
775-
}
764+
}

0 commit comments

Comments
 (0)