@@ -2012,7 +2012,7 @@ fn item_function(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
2012
2012
abi = AbiSpace ( f. abi) ,
2013
2013
name = it. name. as_ref( ) . unwrap( ) ,
2014
2014
generics = f. generics,
2015
- where_clause = WhereClause ( & f. generics, 2 ) ,
2015
+ where_clause = WhereClause { gens : & f. generics, indent : 0 , end_newline : true } ,
2016
2016
decl = Method ( & f. decl, indent) ) ?;
2017
2017
document ( w, cx, it)
2018
2018
}
@@ -2047,8 +2047,7 @@ fn item_trait(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
2047
2047
it. name. as_ref( ) . unwrap( ) ,
2048
2048
t. generics,
2049
2049
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 } ) ?;
2052
2051
2053
2052
let types = t. items . iter ( ) . filter ( |m| m. is_associated_type ( ) ) . collect :: < Vec < _ > > ( ) ;
2054
2053
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,
2087
2086
for m in & provided {
2088
2087
write ! ( w, " " ) ?;
2089
2088
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
+ }
2091
2097
}
2092
2098
write ! ( w, "}}" ) ?;
2093
2099
}
@@ -2327,14 +2333,14 @@ fn render_assoc_item(w: &mut fmt::Formatter,
2327
2333
name,
2328
2334
* g) ;
2329
2335
let mut indent = prefix. len ( ) ;
2330
- let where_indent = if parent == ItemType :: Trait {
2336
+ let ( where_indent, end_newline ) = if parent == ItemType :: Trait {
2331
2337
indent += 4 ;
2332
- 8
2338
+ ( 4 , false )
2333
2339
} else if parent == ItemType :: Impl {
2334
- 2
2340
+ ( 0 , true )
2335
2341
} else {
2336
2342
let prefix = prefix + & format ! ( "{:#}" , Method ( d, indent) ) ;
2337
- prefix. lines ( ) . last ( ) . unwrap ( ) . len ( ) + 1
2343
+ ( prefix. lines ( ) . last ( ) . unwrap ( ) . len ( ) + 1 , true )
2338
2344
} ;
2339
2345
write ! ( w, "{}{}{}fn <a href='{href}' class='fnname'>{name}</a>\
2340
2346
{generics}{decl}{where_clause}",
@@ -2345,7 +2351,11 @@ fn render_assoc_item(w: &mut fmt::Formatter,
2345
2351
name = name,
2346
2352
generics = * g,
2347
2353
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
+ } )
2349
2359
}
2350
2360
match item. inner {
2351
2361
clean:: StrippedItem ( ..) => Ok ( ( ) ) ,
@@ -2458,15 +2468,11 @@ fn item_enum(w: &mut fmt::Formatter, cx: &Context, it: &clean::Item,
2458
2468
e : & clean:: Enum ) -> fmt:: Result {
2459
2469
write ! ( w, "<pre class='rust enum'>" ) ?;
2460
2470
render_attributes ( w, it) ?;
2461
- let padding = format ! ( "{}enum {}{:#} " ,
2462
- VisSpace ( & it. visibility) ,
2463
- it. name. as_ref( ) . unwrap( ) ,
2464
- e. generics) . len ( ) ;
2465
2471
write ! ( w, "{}enum {}{}{}" ,
2466
2472
VisSpace ( & it. visibility) ,
2467
2473
it. name. as_ref( ) . unwrap( ) ,
2468
2474
e. generics,
2469
- WhereClause ( & e. generics, padding ) ) ?;
2475
+ WhereClause { gens : & e. generics, indent : 0 , end_newline : true } ) ?;
2470
2476
if e. variants . is_empty ( ) && !e. variants_stripped {
2471
2477
write ! ( w, " {{}}" ) ?;
2472
2478
} else {
@@ -2640,23 +2646,17 @@ fn render_struct(w: &mut fmt::Formatter, it: &clean::Item,
2640
2646
fields : & [ clean:: Item ] ,
2641
2647
tab : & str ,
2642
2648
structhead : bool ) -> fmt:: Result {
2643
- let mut plain = String :: new ( ) ;
2644
2649
write ! ( w, "{}{}{}" ,
2645
2650
VisSpace ( & it. visibility) ,
2646
2651
if structhead { "struct " } else { "" } ,
2647
2652
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( ) ) ) ;
2652
2653
if let Some ( g) = g {
2653
- plain. push_str ( & format ! ( "{:#}" , g) ) ;
2654
2654
write ! ( w, "{}" , g) ?
2655
2655
}
2656
2656
match ty {
2657
2657
doctree:: Plain => {
2658
2658
if let Some ( g) = g {
2659
- write ! ( w, "{}" , WhereClause ( g, plain . len ( ) + 1 ) ) ?
2659
+ write ! ( w, "{}" , WhereClause { gens : g, indent : 0 , end_newline : true } ) ?
2660
2660
}
2661
2661
let mut has_visible_fields = false ;
2662
2662
write ! ( w, " {{" ) ?;
@@ -2685,35 +2685,30 @@ fn render_struct(w: &mut fmt::Formatter, it: &clean::Item,
2685
2685
}
2686
2686
doctree:: Tuple => {
2687
2687
write ! ( w, "(" ) ?;
2688
- plain. push_str ( "(" ) ;
2689
2688
for ( i, field) in fields. iter ( ) . enumerate ( ) {
2690
2689
if i > 0 {
2691
2690
write ! ( w, ", " ) ?;
2692
- plain. push_str ( ", " ) ;
2693
2691
}
2694
2692
match field. inner {
2695
2693
clean:: StrippedItem ( box clean:: StructFieldItem ( ..) ) => {
2696
- plain. push_str ( "_" ) ;
2697
2694
write ! ( w, "_" ) ?
2698
2695
}
2699
2696
clean:: StructFieldItem ( ref ty) => {
2700
- plain. push_str ( & format ! ( "{}{:#}" , VisSpace ( & field. visibility) , * ty) ) ;
2701
2697
write ! ( w, "{}{}" , VisSpace ( & field. visibility) , * ty) ?
2702
2698
}
2703
2699
_ => unreachable ! ( )
2704
2700
}
2705
2701
}
2706
2702
write ! ( w, ")" ) ?;
2707
- plain. push_str ( ")" ) ;
2708
2703
if let Some ( g) = g {
2709
- write ! ( w, "{}" , WhereClause ( g, plain . len ( ) + 1 ) ) ?
2704
+ write ! ( w, "{}" , WhereClause { gens : g, indent : 0 , end_newline : true } ) ?
2710
2705
}
2711
2706
write ! ( w, ";" ) ?;
2712
2707
}
2713
2708
doctree:: Unit => {
2714
2709
// Needed for PhantomData.
2715
2710
if let Some ( g) = g {
2716
- write ! ( w, "{}" , WhereClause ( g, plain . len ( ) + 1 ) ) ?
2711
+ write ! ( w, "{}" , WhereClause { gens : g, indent : 0 , end_newline : true } ) ?
2717
2712
}
2718
2713
write ! ( w, ";" ) ?;
2719
2714
}
@@ -2726,19 +2721,13 @@ fn render_union(w: &mut fmt::Formatter, it: &clean::Item,
2726
2721
fields : & [ clean:: Item ] ,
2727
2722
tab : & str ,
2728
2723
structhead : bool ) -> fmt:: Result {
2729
- let mut plain = String :: new ( ) ;
2730
2724
write ! ( w, "{}{}{}" ,
2731
2725
VisSpace ( & it. visibility) ,
2732
2726
if structhead { "union " } else { "" } ,
2733
2727
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( ) ) ) ;
2738
2728
if let Some ( g) = g {
2739
2729
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 } ) ?;
2742
2731
}
2743
2732
2744
2733
write ! ( w, " {{\n {}" , tab) ?;
@@ -3037,13 +3026,12 @@ fn render_impl(w: &mut fmt::Formatter, cx: &Context, i: &Impl, link: AssocItemLi
3037
3026
3038
3027
fn item_typedef ( w : & mut fmt:: Formatter , cx : & Context , it : & clean:: Item ,
3039
3028
t : & clean:: Typedef ) -> fmt:: Result {
3040
- let indent = format ! ( "type {}{:#} " , it. name. as_ref( ) . unwrap( ) , t. generics) . len ( ) ;
3041
3029
write ! ( w, "<pre class='rust typedef'>" ) ?;
3042
3030
render_attributes ( w, it) ?;
3043
3031
write ! ( w, "type {}{}{where_clause} = {type_};</pre>" ,
3044
3032
it. name. as_ref( ) . unwrap( ) ,
3045
3033
t. generics,
3046
- where_clause = WhereClause ( & t. generics, indent) ,
3034
+ where_clause = WhereClause { gens : & t. generics, indent: 0 , end_newline : true } ,
3047
3035
type_ = t. type_) ?;
3048
3036
3049
3037
document ( w, cx, it)
0 commit comments