make assoc_const return impl fmt::Display

Author: yotamofek

src/librustdoc/html/render/mod.rs

@@ -879,45 +879,44 @@ enum AssocConstValue<'a> {
     None,
 }
 
-fn assoc_const(
-    w: &mut String,
-    it: &clean::Item,
-    generics: &clean::Generics,
-    ty: &clean::Type,
-    value: AssocConstValue<'_>,
-    link: AssocItemLink<'_>,
+fn assoc_const<'a, 'tcx>(
+    it: &'a clean::Item,
+    generics: &'a clean::Generics,
+    ty: &'a clean::Type,
+    value: AssocConstValue<'a>,
+    link: AssocItemLink<'a>,
     indent: usize,
-    cx: &Context<'_>,
-) {
+    cx: &'a Context<'tcx>,
+) -> impl fmt::Display + 'a + Captures<'tcx> {
     let tcx = cx.tcx();
-    write_str(
-        w,
-        format_args!(
+    fmt::from_fn(move |w| {
+        write!(
+            w,
             "{indent}{vis}const <a{href} class=\"constant\">{name}</a>{generics}: {ty}",
             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),
             ty = ty.print(cx),
-        ),
-    );
-    if let AssocConstValue::TraitDefault(konst) | AssocConstValue::Impl(konst) = value {
-        // FIXME: `.value()` uses `clean::utils::format_integer_with_underscore_sep` under the
-        //        hood which adds noisy underscores and a type suffix to number literals.
-        //        This hurts readability in this context especially when more complex expressions
-        //        are involved and it doesn't add much of value.
-        //        Find a way to print constants here without all that jazz.
-        let repr = konst.value(tcx).unwrap_or_else(|| konst.expr(tcx));
-        if match value {
-            AssocConstValue::TraitDefault(_) => true, // always show
-            AssocConstValue::Impl(_) => repr != "_",  // show if there is a meaningful value to show
-            AssocConstValue::None => unreachable!(),
-        } {
-            write_str(w, format_args!(" = {}", Escape(&repr)));
+        )?;
+        if let AssocConstValue::TraitDefault(konst) | AssocConstValue::Impl(konst) = value {
+            // FIXME: `.value()` uses `clean::utils::format_integer_with_underscore_sep` under the
+            //        hood which adds noisy underscores and a type suffix to number literals.
+            //        This hurts readability in this context especially when more complex expressions
+            //        are involved and it doesn't add much of value.
+            //        Find a way to print constants here without all that jazz.
+            let repr = konst.value(tcx).unwrap_or_else(|| konst.expr(tcx));
+            if match value {
+                AssocConstValue::TraitDefault(_) => true, // always show
+                AssocConstValue::Impl(_) => repr != "_", // show if there is a meaningful value to show
+                AssocConstValue::None => unreachable!(),
+            } {
+                write!(w, " = {}", Escape(&repr))?;
+            }
         }
-    }
-    write_str(w, format_args!("{}", print_where_clause(generics, cx, indent, Ending::NoNewline)));
+        write!(w, "{}", print_where_clause(generics, cx, indent, Ending::NoNewline))
+    })
 }
 
 fn assoc_type(
@@ -1132,36 +1131,57 @@ fn render_assoc_item(
                 ),
             );
         }
-        clean::RequiredAssocConstItem(generics, ty) => assoc_const(
-            w,
-            item,
-            generics,
-            ty,
-            AssocConstValue::None,
-            link,
-            if parent == ItemType::Trait { 4 } else { 0 },
-            cx,
-        ),
-        clean::ProvidedAssocConstItem(ci) => assoc_const(
-            w,
-            item,
-            &ci.generics,
-            &ci.type_,
-            AssocConstValue::TraitDefault(&ci.kind),
-            link,
-            if parent == ItemType::Trait { 4 } else { 0 },
-            cx,
-        ),
-        clean::ImplAssocConstItem(ci) => assoc_const(
-            w,
-            item,
-            &ci.generics,
-            &ci.type_,
-            AssocConstValue::Impl(&ci.kind),
-            link,
-            if parent == ItemType::Trait { 4 } else { 0 },
-            cx,
-        ),
+        clean::RequiredAssocConstItem(generics, ty) => {
+            write_str(
+                w,
+                format_args!(
+                    "{}",
+                    assoc_const(
+                        item,
+                        generics,
+                        ty,
+                        AssocConstValue::None,
+                        link,
+                        if parent == ItemType::Trait { 4 } else { 0 },
+                        cx,
+                    )
+                ),
+            );
+        }
+        clean::ProvidedAssocConstItem(ci) => {
+            write_str(
+                w,
+                format_args!(
+                    "{}",
+                    assoc_const(
+                        item,
+                        &ci.generics,
+                        &ci.type_,
+                        AssocConstValue::TraitDefault(&ci.kind),
+                        link,
+                        if parent == ItemType::Trait { 4 } else { 0 },
+                        cx,
+                    )
+                ),
+            );
+        }
+        clean::ImplAssocConstItem(ci) => {
+            write_str(
+                w,
+                format_args!(
+                    "{}",
+                    assoc_const(
+                        item,
+                        &ci.generics,
+                        &ci.type_,
+                        AssocConstValue::Impl(&ci.kind),
+                        link,
+                        if parent == ItemType::Trait { 4 } else { 0 },
+                        cx,
+                    )
+                ),
+            );
+        }
         clean::RequiredAssocTypeItem(ref generics, ref bounds) => assoc_type(
             w,
             item,
@@ -1779,18 +1799,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_const(
+                write_str(
                     w,
-                    item,
-                    generics,
-                    ty,
-                    AssocConstValue::None,
-                    link.anchor(if trait_.is_some() { &source_id } else { &id }),
-                    0,
-                    cx,
+                    format_args!(
+                        "<h4 class=\"code-header\">{}</h4></section>",
+                        assoc_const(
+                            item,
+                            generics,
+                            ty,
+                            AssocConstValue::None,
+                            link.anchor(if trait_.is_some() { &source_id } else { &id }),
+                            0,
+                            cx,
+                        )
+                    ),
                 );
-                w.push_str("</h4></section>");
             }
             clean::ProvidedAssocConstItem(ci) | clean::ImplAssocConstItem(ci) => {
                 let source_id = format!("{item_type}.{name}");
@@ -1804,22 +1827,26 @@ 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_const(
+                write_str(
                     w,
-                    item,
-                    &ci.generics,
-                    &ci.type_,
-                    match item.kind {
-                        clean::ProvidedAssocConstItem(_) => AssocConstValue::TraitDefault(&ci.kind),
-                        clean::ImplAssocConstItem(_) => AssocConstValue::Impl(&ci.kind),
-                        _ => unreachable!(),
-                    },
-                    link.anchor(if trait_.is_some() { &source_id } else { &id }),
-                    0,
-                    cx,
+                    format_args!(
+                        "<h4 class=\"code-header\">{}</h4></section>",
+                        assoc_const(
+                            item,
+                            &ci.generics,
+                            &ci.type_,
+                            match item.kind {
+                                clean::ProvidedAssocConstItem(_) =>
+                                    AssocConstValue::TraitDefault(&ci.kind),
+                                clean::ImplAssocConstItem(_) => AssocConstValue::Impl(&ci.kind),
+                                _ => unreachable!(),
+                            },
+                            link.anchor(if trait_.is_some() { &source_id } else { &id }),
+                            0,
+                            cx,
+                        )
+                    ),
                 );
-                w.push_str("</h4></section>");
             }
             clean::RequiredAssocTypeItem(ref generics, ref bounds) => {
                 let source_id = format!("{item_type}.{name}");