make print_where_clause return Option<impl fmt::Display>

Author: yotamofek

src/librustdoc/html/format.rs

@@ -30,7 +30,7 @@ use super::url_parts_builder::{UrlPartsBuilder, estimate_item_path_byte_length};
 use crate::clean::types::ExternalLocation;
 use crate::clean::utils::find_nearest_parent_module;
 use crate::clean::{self, ExternalCrate, PrimitiveType};
-use crate::display::Joined as _;
+use crate::display::{Joined as _, MaybeDisplay as _};
 use crate::formats::cache::Cache;
 use crate::formats::item_type::ItemType;
 use crate::html::escape::{Escape, EscapeBodyText};
@@ -178,12 +178,12 @@ pub(crate) fn print_where_clause<'a, 'tcx: 'a>(
     cx: &'a Context<'tcx>,
     indent: usize,
     ending: Ending,
-) -> impl Display + 'a + Captures<'tcx> {
-    fmt::from_fn(move |f| {
-        if gens.where_predicates.is_empty() {
-            return Ok(());
-        }
+) -> Option<impl Display + 'a + Captures<'tcx>> {
+    if gens.where_predicates.is_empty() {
+        return None;
+    }
 
+    Some(fmt::from_fn(move |f| {
         let where_preds = fmt::from_fn(|f| {
             gens.where_predicates
                 .iter()
@@ -246,7 +246,7 @@ pub(crate) fn print_where_clause<'a, 'tcx: 'a>(
             }
         };
         write!(f, "{clause}")
-    })
+    }))
 }
 
 impl clean::Lifetime {
@@ -1179,7 +1179,7 @@ impl clean::Impl {
                 self.print_type(&self.for_, f, use_absolute, cx)?;
             }
 
-            print_where_clause(&self.generics, cx, 0, Ending::Newline).fmt(f)
+            print_where_clause(&self.generics, cx, 0, Ending::Newline).maybe_display().fmt(f)
         })
     }
     fn print_type<'a, 'tcx: 'a>(

src/librustdoc/html/render/mod.rs

@@ -913,7 +913,7 @@ fn assoc_const<'a, 'tcx>(
                 write!(w, " = {}", Escape(&repr))?;
             }
         }
-        write!(w, "{}", print_where_clause(generics, cx, indent, Ending::NoNewline))
+        write!(w, "{}", print_where_clause(generics, cx, indent, Ending::NoNewline).maybe_display())
     })
 }
 
@@ -943,7 +943,7 @@ fn assoc_type<'a, 'tcx>(
         if let Some(default) = default {
             write!(w, " = {}", default.print(cx))?;
         }
-        write!(w, "{}", print_where_clause(generics, cx, indent, Ending::NoNewline))
+        write!(w, "{}", print_where_clause(generics, cx, indent, Ending::NoNewline).maybe_display())
     })
 }
 
@@ -1008,7 +1008,7 @@ fn assoc_method<'a, 'tcx>(
             indent = indent_str,
             generics = g.print(cx),
             decl = d.full_print(header_len, indent, cx),
-            where_clause = print_where_clause(g, cx, indent, end_newline),
+            where_clause = print_where_clause(g, cx, indent, end_newline).maybe_display(),
         )
     })
 }

src/librustdoc/html/render/print_item.rs

@@ -162,17 +162,6 @@ struct ItemVars<'a> {
     src_href: Option<&'a str>,
 }
 
-/// Calls `print_where_clause` and returns `true` if a `where` clause was generated.
-fn print_where_clause_and_check<'a, 'tcx: 'a>(
-    buffer: &mut String,
-    gens: &'a clean::Generics,
-    cx: &'a Context<'tcx>,
-) -> bool {
-    let len_before = buffer.len();
-    write_str(buffer, format_args!("{}", print_where_clause(gens, cx, 0, Ending::Newline)));
-    len_before != buffer.len()
-}
-
 pub(super) fn print_item(cx: &Context<'_>, item: &clean::Item, buf: &mut String) {
     debug_assert!(!item.is_stripped());
     let typ = match item.kind {
@@ -638,7 +627,8 @@ fn item_function<'a, 'tcx>(
                 abi = abi,
                 name = name,
                 generics = f.generics.print(cx),
-                where_clause = print_where_clause(&f.generics, cx, 0, Ending::Newline),
+                where_clause =
+                    print_where_clause(&f.generics, cx, 0, Ending::Newline).maybe_display(),
                 decl = f.decl.full_print(header_len, 0, cx),
             )
         })?;
@@ -682,7 +672,11 @@ fn item_trait<'a, 'tcx>(
             )?;
 
             if !t.generics.where_predicates.is_empty() {
-                write!(w, "{}", print_where_clause(&t.generics, cx, 0, Ending::Newline))?;
+                write!(
+                    w,
+                    "{}",
+                    print_where_clause(&t.generics, cx, 0, Ending::Newline).maybe_display()
+                )?;
             } else {
                 w.write_char(' ')?;
             }
@@ -1252,7 +1246,7 @@ fn item_trait_alias(
             attrs = render_attributes_in_pre(it, "", cx),
             name = it.name.unwrap(),
             generics = t.generics.print(cx),
-            where_b = print_where_clause(&t.generics, cx, 0, Ending::Newline),
+            where_b = print_where_clause(&t.generics, cx, 0, Ending::Newline).maybe_display(),
             bounds = bounds(&t.bounds, true, cx),
         )
         .unwrap();
@@ -1277,7 +1271,8 @@ fn item_type_alias(w: &mut String, cx: &Context<'_>, it: &clean::Item, t: &clean
                 vis = visibility_print_with_space(it, cx),
                 name = it.name.unwrap(),
                 generics = t.generics.print(cx),
-                where_clause = print_where_clause(&t.generics, cx, 0, Ending::Newline),
+                where_clause =
+                    print_where_clause(&t.generics, cx, 0, Ending::Newline).maybe_display(),
                 type_ = t.type_.print(cx),
             ),
         );
@@ -1651,9 +1646,13 @@ fn render_enum_fields(
     enum_def_id: DefId,
 ) {
     let should_show_enum_discriminant = should_show_enum_discriminant(cx, enum_def_id, variants);
-    if !g.is_some_and(|g| print_where_clause_and_check(w, g, cx)) {
+    if let Some(generics) = g
+        && let Some(where_clause) = print_where_clause(generics, cx, 0, Ending::Newline)
+    {
+        write_str(w, format_args!("{where_clause}"));
+    } else {
         // If there wasn't a `where` clause, we add a whitespace.
-        w.push_str(" ");
+        w.push(' ')
     }
 
     let variants_stripped = has_stripped_entries;
@@ -1930,7 +1929,8 @@ fn item_constant(
                 name = it.name.unwrap(),
                 generics = generics.print(cx),
                 typ = ty.print(cx),
-                where_clause = print_where_clause(generics, cx, 0, Ending::NoNewline)
+                where_clause =
+                    print_where_clause(generics, cx, 0, Ending::NoNewline).maybe_display(),
             ),
         );
 
@@ -2295,14 +2295,17 @@ fn render_union<'a, 'cx: 'a>(
     fmt::from_fn(move |mut f| {
         write!(f, "{}union {}", visibility_print_with_space(it, cx), it.name.unwrap(),)?;
 
-        let where_displayed = g
-            .map(|g| {
-                let mut buf = g.print(cx).to_string();
-                let where_displayed = print_where_clause_and_check(&mut buf, g, cx);
-                f.write_str(&buf).unwrap();
-                where_displayed
-            })
-            .unwrap_or(false);
+        let where_displayed = if let Some(generics) = g {
+            write!(f, "{}", generics.print(cx))?;
+            if let Some(where_clause) = print_where_clause(generics, cx, 0, Ending::Newline) {
+                write!(f, "{where_clause}")?;
+                true
+            } else {
+                false
+            }
+        } else {
+            false
+        };
 
         // If there wasn't a `where` clause, we add a whitespace.
         if !where_displayed {
@@ -2386,8 +2389,14 @@ fn render_struct_fields(
 ) {
     match ty {
         None => {
-            let where_displayed =
-                g.map(|g| print_where_clause_and_check(w, g, cx)).unwrap_or(false);
+            let where_displayed = if let Some(generics) = g
+                && let Some(where_clause) = print_where_clause(generics, cx, 0, Ending::Newline)
+            {
+                write_str(w, format_args!("{where_clause}"));
+                true
+            } else {
+                false
+            };
 
             // If there wasn't a `where` clause, we add a whitespace.
             if !where_displayed {
@@ -2467,7 +2476,13 @@ fn render_struct_fields(
             }
             w.push_str(")");
             if let Some(g) = g {
-                write_str(w, format_args!("{}", print_where_clause(g, cx, 0, Ending::NoNewline)));
+                write_str(
+                    w,
+                    format_args!(
+                        "{}",
+                        print_where_clause(g, cx, 0, Ending::NoNewline).maybe_display()
+                    ),
+                );
             }
             // We only want a ";" when we are displaying a tuple struct, not a variant tuple struct.
             if structhead {
@@ -2477,7 +2492,13 @@ fn render_struct_fields(
         Some(CtorKind::Const) => {
             // Needed for PhantomData.
             if let Some(g) = g {
-                write_str(w, format_args!("{}", print_where_clause(g, cx, 0, Ending::NoNewline)));
+                write_str(
+                    w,
+                    format_args!(
+                        "{}",
+                        print_where_clause(g, cx, 0, Ending::NoNewline).maybe_display()
+                    ),
+                );
             }
             w.push_str(";");
         }