make assoc_type return impl fmt::Display

Author: yotamofek

src/librustdoc/html/render/mod.rs

@@ -919,35 +919,34 @@ fn assoc_const<'a, 'tcx>(
     })
 }
 
-fn assoc_type(
-    w: &mut String,
-    it: &clean::Item,
-    generics: &clean::Generics,
-    bounds: &[clean::GenericBound],
-    default: Option<&clean::Type>,
-    link: AssocItemLink<'_>,
+fn assoc_type<'a, 'tcx>(
+    it: &'a clean::Item,
+    generics: &'a clean::Generics,
+    bounds: &'a [clean::GenericBound],
+    default: Option<&'a clean::Type>,
+    link: AssocItemLink<'a>,
     indent: usize,
-    cx: &Context<'_>,
-) {
-    write_str(
-        w,
-        format_args!(
+    cx: &'a Context<'tcx>,
+) -> impl fmt::Display + 'a + Captures<'tcx> {
+    fmt::from_fn(move |w| {
+        write!(
+            w,
             "{indent}{vis}type <a{href} class=\"associatedtype\">{name}</a>{generics}",
             indent = " ".repeat(indent),
             vis = visibility_print_with_space(it, cx),
             href = assoc_href_attr(it, link, cx).maybe_display(),
             name = it.name.as_ref().unwrap(),
             generics = generics.print(cx),
-        ),
-    );
-    if !bounds.is_empty() {
-        write_str(w, format_args!(": {}", print_generic_bounds(bounds, cx)));
-    }
-    // Render the default before the where-clause which aligns with the new recommended style. See #89122.
-    if let Some(default) = default {
-        write_str(w, format_args!(" = {}", default.print(cx)));
-    }
-    write_str(w, format_args!("{}", print_where_clause(generics, cx, indent, Ending::NoNewline)));
+        )?;
+        if !bounds.is_empty() {
+            write!(w, ": {}", print_generic_bounds(bounds, cx))?;
+        }
+        // Render the default before the where-clause which aligns with the new recommended style. See #89122.
+        if let Some(default) = default {
+            write!(w, " = {}", default.print(cx))?;
+        }
+        write!(w, "{}", print_where_clause(generics, cx, indent, Ending::NoNewline))
+    })
 }
 
 fn assoc_method<'a, 'tcx>(
@@ -1182,26 +1181,40 @@ fn render_assoc_item(
                 ),
             );
         }
-        clean::RequiredAssocTypeItem(ref generics, ref bounds) => assoc_type(
-            w,
-            item,
-            generics,
-            bounds,
-            None,
-            link,
-            if parent == ItemType::Trait { 4 } else { 0 },
-            cx,
-        ),
-        clean::AssocTypeItem(ref ty, ref bounds) => assoc_type(
-            w,
-            item,
-            &ty.generics,
-            bounds,
-            Some(ty.item_type.as_ref().unwrap_or(&ty.type_)),
-            link,
-            if parent == ItemType::Trait { 4 } else { 0 },
-            cx,
-        ),
+        clean::RequiredAssocTypeItem(ref generics, ref bounds) => {
+            write_str(
+                w,
+                format_args!(
+                    "{}",
+                    assoc_type(
+                        item,
+                        generics,
+                        bounds,
+                        None,
+                        link,
+                        if parent == ItemType::Trait { 4 } else { 0 },
+                        cx,
+                    )
+                ),
+            );
+        }
+        clean::AssocTypeItem(ref ty, ref bounds) => {
+            write_str(
+                w,
+                format_args!(
+                    "{}",
+                    assoc_type(
+                        item,
+                        &ty.generics,
+                        bounds,
+                        Some(ty.item_type.as_ref().unwrap_or(&ty.type_)),
+                        link,
+                        if parent == ItemType::Trait { 4 } else { 0 },
+                        cx,
+                    )
+                ),
+            );
+        }
         _ => panic!("render_assoc_item called on non-associated-item"),
     }
 }
@@ -1578,20 +1591,23 @@ fn notable_traits_decl(ty: &clean::Type, cx: &Context<'_>) -> (String, String) {
                 );
                 for it in &impl_.items {
                     if let clean::AssocTypeItem(ref tydef, ref _bounds) = it.kind {
-                        out.push_str("<div class=\"where\">    ");
                         let empty_set = FxIndexSet::default();
                         let src_link = AssocItemLink::GotoSource(trait_did.into(), &empty_set);
-                        assoc_type(
+                        write_str(
                             &mut out,
-                            it,
-                            &tydef.generics,
-                            &[], // intentionally leaving out bounds
-                            Some(&tydef.type_),
-                            src_link,
-                            0,
-                            cx,
+                            format_args!(
+                                "<div class=\"where\">    {};</div>",
+                                assoc_type(
+                                    it,
+                                    &tydef.generics,
+                                    &[], // intentionally leaving out bounds
+                                    Some(&tydef.type_),
+                                    src_link,
+                                    0,
+                                    cx,
+                                )
+                            ),
                         );
-                        out.push_str(";</div>");
                     }
                 }
             }
@@ -1860,18 +1876,21 @@ fn render_impl(
                     // Anchors are only used on trait impls.
                     write_str(w, format_args!("<a href=\"#{id}\" class=\"anchor\">§</a>"));
                 }
-                w.push_str("<h4 class=\"code-header\">");
-                assoc_type(
+                write_str(
                     w,
-                    item,
-                    generics,
-                    bounds,
-                    None,
-                    link.anchor(if trait_.is_some() { &source_id } else { &id }),
-                    0,
-                    cx,
+                    format_args!(
+                        "<h4 class=\"code-header\">{}</h4></section>",
+                        assoc_type(
+                            item,
+                            generics,
+                            bounds,
+                            None,
+                            link.anchor(if trait_.is_some() { &source_id } else { &id }),
+                            0,
+                            cx,
+                        )
+                    ),
                 );
-                w.push_str("</h4></section>");
             }
             clean::AssocTypeItem(tydef, _bounds) => {
                 let source_id = format!("{item_type}.{name}");
@@ -1885,18 +1904,21 @@ fn render_impl(
                     // Anchors are only used on trait impls.
                     write_str(w, format_args!("<a href=\"#{id}\" class=\"anchor\">§</a>"));
                 }
-                w.push_str("<h4 class=\"code-header\">");
-                assoc_type(
+                write_str(
                     w,
-                    item,
-                    &tydef.generics,
-                    &[], // intentionally leaving out bounds
-                    Some(tydef.item_type.as_ref().unwrap_or(&tydef.type_)),
-                    link.anchor(if trait_.is_some() { &source_id } else { &id }),
-                    0,
-                    cx,
+                    format_args!(
+                        "<h4 class=\"code-header\">{}</h4></section>",
+                        assoc_type(
+                            item,
+                            &tydef.generics,
+                            &[], // intentionally leaving out bounds
+                            Some(tydef.item_type.as_ref().unwrap_or(&tydef.type_)),
+                            link.anchor(if trait_.is_some() { &source_id } else { &id }),
+                            0,
+                            cx,
+                        )
+                    ),
                 );
-                w.push_str("</h4></section>");
             }
             clean::StrippedItem(..) => return,
             _ => panic!("can't make docs for trait item with name {:?}", item.name),
@@ -2192,18 +2214,21 @@ pub(crate) fn render_impl_summary(
         if show_def_docs {
             for it in &inner_impl.items {
                 if let clean::AssocTypeItem(ref tydef, ref _bounds) = it.kind {
-                    w.push_str("<div class=\"where\">  ");
-                    assoc_type(
+                    write_str(
                         w,
-                        it,
-                        &tydef.generics,
-                        &[], // intentionally leaving out bounds
-                        Some(&tydef.type_),
-                        AssocItemLink::Anchor(None),
-                        0,
-                        cx,
+                        format_args!(
+                            "<div class=\"where\">  {};</div>",
+                            assoc_type(
+                                it,
+                                &tydef.generics,
+                                &[], // intentionally leaving out bounds
+                                Some(&tydef.type_),
+                                AssocItemLink::Anchor(None),
+                                0,
+                                cx,
+                            )
+                        ),
                     );
-                    w.push_str(";</div>");
                 }
             }
         }