another attempt

Author: yotamofek

src/librustdoc/clean/cfg.rs

@@ -14,7 +14,7 @@ use rustc_span::Span;
 use rustc_span::symbol::{Symbol, sym};
 
 use crate::html::escape::Escape;
-use crate::join::Join as _;
+use crate::join::Joined as _;
 
 #[cfg(test)]
 mod tests;
@@ -417,25 +417,27 @@ impl Display<'_> {
             }
         };
 
-        (|| {
-            sub_cfgs.iter().map(|sub_cfg| {
-                fmt::from_fn(move |fmt| {
-                    if let Cfg::Cfg(_, Some(feat)) = sub_cfg
-                        && short_longhand
-                    {
-                        if self.1.is_html() {
-                            write!(fmt, "<code>{feat}</code>")?;
+        fmt::from_fn(|f| {
+            sub_cfgs
+                .iter()
+                .map(|sub_cfg| {
+                    fmt::from_fn(move |fmt| {
+                        if let Cfg::Cfg(_, Some(feat)) = sub_cfg
+                            && short_longhand
+                        {
+                            if self.1.is_html() {
+                                write!(fmt, "<code>{feat}</code>")?;
+                            } else {
+                                write!(fmt, "`{feat}`")?;
+                            }
                         } else {
-                            write!(fmt, "`{feat}`")?;
+                            write_with_opt_paren(fmt, !sub_cfg.is_all(), Display(sub_cfg, self.1))?;
                         }
-                    } else {
-                        write_with_opt_paren(fmt, !sub_cfg.is_all(), Display(sub_cfg, self.1))?;
-                    }
-                    Ok(())
+                        Ok(())
+                    })
                 })
-            })
+                .joined(separator, f)
         })
-        .join(separator)
         .fmt(fmt)?;
 
         Ok(())
@@ -450,8 +452,10 @@ impl fmt::Display for Display<'_> {
                     let separator =
                         if sub_cfgs.iter().all(Cfg::is_simple) { " nor " } else { ", nor " };
                     fmt.write_str("neither ")?;
-                    (|| {
-                        sub_cfgs.iter().map(|sub_cfg| {
+
+                    sub_cfgs
+                        .iter()
+                        .map(|sub_cfg| {
                             fmt::from_fn(|fmt| {
                                 write_with_opt_paren(
                                     fmt,
@@ -460,9 +464,7 @@ impl fmt::Display for Display<'_> {
                                 )
                             })
                         })
-                    })
-                    .join(separator)
-                    .fmt(fmt)
+                        .joined(separator, fmt)
                 }
                 ref simple @ Cfg::Cfg(..) => write!(fmt, "non-{}", Display(simple, self.1)),
                 ref c => write!(fmt, "not ({})", Display(c, self.1)),

src/librustdoc/html/format.rs

@@ -33,7 +33,7 @@ use crate::formats::cache::Cache;
 use crate::formats::item_type::ItemType;
 use crate::html::escape::{Escape, EscapeBodyText};
 use crate::html::render::Context;
-use crate::join::Join as _;
+use crate::join::Joined as _;
 use crate::passes::collect_intra_doc_links::UrlFragment;
 
 pub(crate) trait Print {
@@ -150,13 +150,13 @@ pub(crate) fn print_generic_bounds<'a, 'tcx: 'a>(
     cx: &'a Context<'tcx>,
 ) -> impl Display + 'a + Captures<'tcx> {
     fmt::from_fn(move |f| {
-        (|| {
-            let mut bounds_dup = FxHashSet::default();
+        let mut bounds_dup = FxHashSet::default();
 
-            bounds.iter().filter(move |b| bounds_dup.insert(*b)).map(|bound| bound.print(cx))
-        })
-        .join(" + ")
-        .fmt(f)
+        bounds
+            .iter()
+            .filter(move |b| bounds_dup.insert(*b))
+            .map(|bound| bound.print(cx))
+            .joined(" + ", f)
     })
 }
 
@@ -171,7 +171,7 @@ impl clean::GenericParamDef {
 
                 if !outlives.is_empty() {
                     f.write_str(": ")?;
-                    write!(f, "{}", (|| outlives.iter().map(|lt| lt.print())).join(" + "))?;
+                    outlives.iter().map(|lt| lt.print()).joined(" + ", f)?; // TODO: keep fmt options?
                 }
 
                 Ok(())
@@ -221,7 +221,8 @@ impl clean::Generics {
                 return Ok(());
             }
 
-            let real_params = (|| real_params.clone().map(|g| g.print(cx))).join(", ");
+            let real_params =
+                fmt::from_fn(|f| real_params.clone().map(|g| g.print(cx)).joined(", ", f));
             if f.alternate() {
                 write!(f, "<{:#}>", real_params)
             } else {
@@ -293,7 +294,7 @@ pub(crate) fn print_where_clause<'a, 'tcx: 'a>(
             })
         };
 
-        let where_preds = where_predicates.join(",");
+        let where_preds = fmt::from_fn(|f| where_predicates().joined(",", f));
         let clause = if f.alternate() {
             if ending == Ending::Newline {
                 format!(" where{where_preds},")
@@ -390,7 +391,7 @@ impl clean::GenericBound {
                 } else {
                     f.write_str("use&lt;")?;
                 }
-                (|| args.iter()).join(", ").fmt(f)?;
+                args.iter().joined(", ", f)?;
                 if f.alternate() { f.write_str(">") } else { f.write_str("&gt;") }
             }
         })
@@ -494,7 +495,7 @@ pub(crate) enum HrefError {
 // Panics if `syms` is empty.
 pub(crate) fn join_with_double_colon(syms: &[Symbol]) -> String {
     let mut s = String::with_capacity(estimate_item_path_byte_length(syms.len()));
-    write!(s, "{}", (|| syms.iter()).join("::")).unwrap();
+    write!(s, "{}", fmt::from_fn(|f| syms.iter().joined("::", f))).unwrap();
     s
 }
 
@@ -544,14 +545,14 @@ fn generate_macro_def_id_path(
     let url = match cache.extern_locations[&def_id.krate] {
         ExternalLocation::Remote(ref s) => {
             // `ExternalLocation::Remote` always end with a `/`.
-            format!("{s}{path}", path = (|| path.iter()).join("/"))
+            format!("{s}{path}", path = fmt::from_fn(|f| path.iter().joined("/", f)))
         }
         ExternalLocation::Local => {
             // `root_path` always end with a `/`.
             format!(
                 "{root_path}{path}",
                 root_path = root_path.unwrap_or(""),
-                path = (|| path.iter()).join("/")
+                path = fmt::from_fn(|f| path.iter().joined("/", f))
             )
         }
         ExternalLocation::Unknown => {
@@ -915,7 +916,7 @@ fn tybounds<'a, 'tcx: 'a>(
     cx: &'a Context<'tcx>,
 ) -> impl Display + 'a + Captures<'tcx> {
     fmt::from_fn(move |f| {
-        (|| bounds.iter().map(|bound| bound.print(cx))).join(" + ").fmt(f)?;
+        bounds.iter().map(|bound| bound.print(cx)).joined(" + ", f)?;
         if let Some(lt) = lt {
             // We don't need to check `alternate` since we can be certain that
             // the lifetime doesn't contain any characters which need escaping.
@@ -934,7 +935,7 @@ fn print_higher_ranked_params_with_space<'a, 'tcx: 'a>(
         if !params.is_empty() {
             f.write_str(keyword)?;
             f.write_str(if f.alternate() { "<" } else { "&lt;" })?;
-            (|| params.iter().map(|lt| lt.print(cx))).join(", ").fmt(f)?;
+            params.iter().map(|lt| lt.print(cx)).joined(", ", f)?;
             f.write_str(if f.alternate() { "> " } else { "&gt; " })?;
         }
         Ok(())
@@ -1025,12 +1026,15 @@ fn fmt_type(
                     primitive_link(
                         f,
                         PrimitiveType::Tuple,
-                        format_args!("({})", (|| generic_names.iter()).join(", ")),
+                        format_args!(
+                            "({})",
+                            fmt::from_fn(|f| generic_names.iter().joined(", ", f))
+                        ),
                         cx,
                     )
                 } else {
                     f.write_str("(")?;
-                    (|| many.iter().map(|item| item.print(cx))).join(", ").fmt(f)?;
+                    many.iter().map(|item| item.print(cx)).joined(", ", f)?;
                     f.write_str(")")
                 }
             }
@@ -1360,16 +1364,15 @@ impl clean::Arguments {
         cx: &'a Context<'tcx>,
     ) -> impl Display + 'a + Captures<'tcx> {
         fmt::from_fn(move |f| {
-            (|| {
-                self.values.iter().map(|input| {
+            self.values
+                .iter()
+                .map(|input| {
                     fmt::from_fn(|f| {
                         write!(f, "{}: ", input.name)?;
                         input.type_.print(cx).fmt(f)
                     })
                 })
-            })
-            .join(", ")
-            .fmt(f)
+                .joined(", ", f)
         })
     }
 }

src/librustdoc/html/render/print_item.rs

@@ -2,7 +2,6 @@ use std::cmp::Ordering;
 use std::fmt;
 use std::fmt::{Display, Write};
 
-use itertools::Itertools;
 use rinja::Template;
 use rustc_abi::VariantIdx;
 use rustc_data_structures::captures::Captures;
@@ -37,7 +36,7 @@ use crate::html::format::{
 use crate::html::markdown::{HeadingOffset, MarkdownSummaryLine};
 use crate::html::render::{document_full, document_item_info};
 use crate::html::url_parts_builder::UrlPartsBuilder;
-use crate::join::Join as _;
+use crate::join::Joined as _;
 
 /// Generates a Rinja template struct for rendering items with common methods.
 ///
@@ -499,11 +498,11 @@ fn item_module(w: &mut Buffer, cx: &Context<'_>, item: &clean::Item, items: &[cl
                     class = myitem.type_(),
                     unsafety_flag = unsafety_flag,
                     href = item_path(myitem.type_(), myitem.name.unwrap().as_str()),
-                    title = [myitem.type_().to_string(), full_path(cx, myitem)]
+                    title = fmt::from_fn(|f| [myitem.type_().to_string(), full_path(cx, myitem)]
                         .iter()
                         .filter_map(|s| if !s.is_empty() { Some(s.as_str()) } else { None })
                         .collect::<Vec<_>>()
-                        .join(" "),
+                        .joined(" ", f)),
                 );
             }
         }
@@ -883,7 +882,7 @@ fn item_trait(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, t: &clean::Tra
             write!(
                 w,
                 "<div class=\"stab must_implement\">At least one of the `{}` methods is required.</div>",
-                list.iter().join("`, `")
+                fmt::from_fn(|f| list.iter().joined("`, `", f))
             );
         }
 
@@ -1433,17 +1432,15 @@ fn print_tuple_struct_fields<'a, 'cx: 'a>(
             return f.write_str("<span class=\"comment\">/* private fields */</span>");
         }
 
-        (|| {
-            s.iter().map(|ty| {
+        s.iter()
+            .map(|ty| {
                 fmt::from_fn(|f| match ty.kind {
                     clean::StrippedItem(box clean::StructFieldItem(_)) => f.write_str("_"),
                     clean::StructFieldItem(ref ty) => write!(f, "{}", ty.print(cx)),
                     _ => unreachable!(),
                 })
             })
-        })
-        .join(", ")
-        .fmt(f)
+            .joined(", ", f)
     })
 }
 
@@ -2066,7 +2063,12 @@ fn bounds(t_bounds: &[clean::GenericBound], trait_alias: bool, cx: &Context<'_>)
             bounds.push_str(": ");
         }
     }
-    write!(bounds, "{}", (|| t_bounds.iter().map(|p| p.print(cx))).join(inter_str)).unwrap();
+    write!(
+        bounds,
+        "{}",
+        fmt::from_fn(|f| t_bounds.iter().map(|p| p.print(cx)).joined(inter_str, f))
+    )
+    .unwrap();
     bounds
 }
 

src/librustdoc/join.rs

@@ -1,30 +1,22 @@
-use std::fmt::{self, Display};
+use std::fmt::{self, Display, Formatter};
 
-pub(crate) trait Join {
-    fn join<'f, 'sep: 'f>(self, sep: &'sep str) -> impl Display + 'f
-    where
-        Self: 'f;
+pub(crate) trait Joined {
+    fn joined(self, sep: &str, f: &mut Formatter<'_>) -> fmt::Result;
 }
 
-impl<F, I, T> Join for F
+impl<I, T> Joined for I
 where
-    F: Fn() -> I,
-    I: Iterator<Item = T>,
+    I: IntoIterator<Item = T>,
     T: Display,
 {
-    fn join<'f, 'sep: 'f>(self, sep: &'sep str) -> impl Display + 'f
-    where
-        Self: 'f,
-    {
-        fmt::from_fn(move |f| {
-            let mut iter = self();
-            let Some(first) = iter.next() else { return Ok(()) };
-            first.fmt(f)?;
-            while let Some(item) = iter.next() {
-                f.write_str(sep)?;
-                item.fmt(f)?;
-            }
-            Ok(())
-        })
+    fn joined(self, sep: &str, f: &mut Formatter<'_>) -> fmt::Result {
+        let mut iter = self.into_iter();
+        let Some(first) = iter.next() else { return Ok(()) };
+        first.fmt(f)?;
+        while let Some(item) = iter.next() {
+            f.write_str(sep)?;
+            item.fmt(f)?;
+        }
+        Ok(())
     }
 }