Use display_fn for render_attributes_in_code

Author: nicklimmm

src/librustdoc/html/render/mod.rs

@@ -854,7 +854,7 @@ fn assoc_method(
         write!(w, "{}", render_attributes_in_pre(meth, indent_str, tcx));
         (4, indent_str, Ending::NoNewline)
     } else {
-        render_attributes_in_code(w, meth, tcx);
+        write!(w, "{}", render_attributes_in_code(meth, tcx));
         (0, "", Ending::Newline)
     };
     w.reserve(header_len + "<a href=\"\" class=\"fn\">{".len() + "</a>".len());
@@ -1040,10 +1040,16 @@ fn render_attributes_in_pre<'a, 'b: 'a>(
 
 // When an attribute is rendered inside a <code> tag, it is formatted using
 // a div to produce a newline after it.
-fn render_attributes_in_code(w: &mut impl fmt::Write, it: &clean::Item, tcx: TyCtxt<'_>) {
-    for attr in it.attributes(tcx, false) {
-        write!(w, "<div class=\"code-attribute\">{attr}</div>").unwrap();
-    }
+fn render_attributes_in_code<'a, 'tcx>(
+    it: &'a clean::Item,
+    tcx: TyCtxt<'tcx>,
+) -> impl fmt::Display + Captures<'a> + Captures<'tcx> {
+    display_fn(move |f| {
+        for a in it.attributes(tcx, false) {
+            write!(f, "<div class=\"code-attribute\">{}</div>", a)?;
+        }
+        Ok(())
+    })
 }
 
 #[derive(Copy, Clone)]

src/librustdoc/html/render/print_item.rs

@@ -1334,13 +1334,13 @@ fn item_enum(w: &mut Buffer, cx: &mut Context<'_>, it: &clean::Item, e: &clean::
     let tcx = cx.tcx();
     let count_variants = e.variants().count();
     wrap_item(w, |mut w| {
-        render_attributes_in_code(w, it, tcx);
         write!(
             w,
-            "{}enum {}{}",
+            "{attrs}{}enum {}{}",
             visibility_print_with_space(it.visibility(tcx), it.item_id, cx),
             it.name.unwrap(),
             e.generics.print(cx),
+            attrs = render_attributes_in_code(it, tcx),
         );
         if !print_where_clause_and_check(w, &e.generics, cx) {
             // If there wasn't a `where` clause, we add a whitespace.
@@ -1539,11 +1539,11 @@ fn item_primitive(w: &mut impl fmt::Write, cx: &mut Context<'_>, it: &clean::Ite
 fn item_constant(w: &mut Buffer, cx: &mut Context<'_>, it: &clean::Item, c: &clean::Constant) {
     wrap_item(w, |w| {
         let tcx = cx.tcx();
-        render_attributes_in_code(w, it, tcx);
 
         write!(
             w,
-            "{vis}const {name}: {typ}",
+            "{attrs}{vis}const {name}: {typ}",
+            attrs = render_attributes_in_code(it, tcx),
             vis = visibility_print_with_space(it.visibility(tcx), it.item_id, cx),
             name = it.name.unwrap(),
             typ = c.type_.print(cx),
@@ -1586,7 +1586,7 @@ fn item_constant(w: &mut Buffer, cx: &mut Context<'_>, it: &clean::Item, c: &cle
 
 fn item_struct(w: &mut Buffer, cx: &mut Context<'_>, it: &clean::Item, s: &clean::Struct) {
     wrap_item(w, |w| {
-        render_attributes_in_code(w, it, cx.tcx());
+        write!(w, "{}", render_attributes_in_code(it, cx.tcx()));
         render_struct(w, it, Some(&s.generics), s.ctor_kind, &s.fields, "", true, cx);
     });
 
@@ -1636,10 +1636,10 @@ fn item_struct(w: &mut Buffer, cx: &mut Context<'_>, it: &clean::Item, s: &clean
 
 fn item_static(w: &mut impl fmt::Write, cx: &mut Context<'_>, it: &clean::Item, s: &clean::Static) {
     wrap_item(w, |buffer| {
-        render_attributes_in_code(buffer, it, cx.tcx());
         write!(
             buffer,
-            "{vis}static {mutability}{name}: {typ}",
+            "{attrs}{vis}static {mutability}{name}: {typ}",
+            attrs = render_attributes_in_code(it, cx.tcx()),
             vis = visibility_print_with_space(it.visibility(cx.tcx()), it.item_id, cx),
             mutability = s.mutability.print_with_space(),
             name = it.name.unwrap(),
@@ -1654,12 +1654,12 @@ fn item_static(w: &mut impl fmt::Write, cx: &mut Context<'_>, it: &clean::Item,
 fn item_foreign_type(w: &mut impl fmt::Write, cx: &mut Context<'_>, it: &clean::Item) {
     wrap_item(w, |buffer| {
         buffer.write_str("extern {\n").unwrap();
-        render_attributes_in_code(buffer, it, cx.tcx());
         write!(
             buffer,
-            "    {}type {};\n}}",
+            "{attrs}    {}type {};\n}}",
             visibility_print_with_space(it.visibility(cx.tcx()), it.item_id, cx),
             it.name.unwrap(),
+            attrs = render_attributes_in_code(it, cx.tcx()),
         )
         .unwrap();
     });