Cleanup FnDecl::inner_full_print

Author: yotamofek

src/librustdoc/display.rs

@@ -10,20 +10,20 @@ pub(crate) trait Joined: IntoIterator {
     ///
     /// The performance of `joined` is slightly better than `format`, since it doesn't need to use a `Cell` to keep track of whether [`fmt`](Display::fmt)
     /// was already called (`joined`'s API doesn't allow it be called more than once).
-    fn joined(self, sep: &str, f: &mut Formatter<'_>) -> fmt::Result;
+    fn joined(self, sep: impl Display, f: &mut Formatter<'_>) -> fmt::Result;
 }
 
 impl<I, T> Joined for I
 where
     I: IntoIterator<Item = T>,
     T: Display,
 {
-    fn joined(self, sep: &str, f: &mut Formatter<'_>) -> fmt::Result {
+    fn joined(self, sep: impl Display, f: &mut Formatter<'_>) -> fmt::Result {
         let mut iter = self.into_iter();
         let Some(first) = iter.next() else { return Ok(()) };
         first.fmt(f)?;
         for item in iter {
-            f.write_str(sep)?;
+            sep.fmt(f)?;
             item.fmt(f)?;
         }
         Ok(())

src/librustdoc/html/format.rs

@@ -29,7 +29,7 @@ use tracing::{debug, trace};
 use super::url_parts_builder::UrlPartsBuilder;
 use crate::clean::types::ExternalLocation;
 use crate::clean::utils::find_nearest_parent_module;
-use crate::clean::{self, ExternalCrate, PrimitiveType};
+use crate::clean::{self, ExternalCrate, Parameter, PrimitiveType};
 use crate::display::{Joined as _, MaybeDisplay as _};
 use crate::formats::cache::Cache;
 use crate::formats::item_type::ItemType;
@@ -1264,6 +1264,7 @@ impl std::fmt::Write for WriteCounter {
 }
 
 // Implements Display by emitting the given number of spaces.
+#[derive(Clone, Copy)]
 struct Indent(usize);
 
 impl Display for Indent {
@@ -1325,40 +1326,21 @@ impl clean::FnDecl {
         })
     }
 
-    fn inner_full_print(
-        &self,
-        // For None, the declaration will not be line-wrapped. For Some(n),
-        // the declaration will be line-wrapped, with an indent of n spaces.
-        line_wrapping_indent: Option<usize>,
-        f: &mut fmt::Formatter<'_>,
-        cx: &Context<'_>,
-    ) -> fmt::Result {
-        let amp = if f.alternate() { "&" } else { "&amp;" };
-
-        write!(f, "(")?;
-        if let Some(n) = line_wrapping_indent
-            && !self.inputs.is_empty()
-        {
-            write!(f, "\n{}", Indent(n + 4))?;
-        }
-
-        let last_input_index = self.inputs.len().checked_sub(1);
-        for (i, param) in self.inputs.iter().enumerate() {
-            if let Some(selfty) = param.to_receiver() {
-                match selfty {
-                    clean::SelfTy => {
-                        write!(f, "self")?;
-                    }
+    fn print_param(param: &Parameter, cx: &Context<'_>) -> impl fmt::Display {
+        fmt::from_fn(move |f| {
+            if let Some(self_ty) = param.to_receiver() {
+                match self_ty {
+                    clean::SelfTy => f.write_str("self"),
                     clean::BorrowedRef { lifetime, mutability, type_: box clean::SelfTy } => {
-                        write!(f, "{amp}")?;
+                        f.write_str(if f.alternate() { "&" } else { "&amp;" })?;
                         if let Some(lt) = lifetime {
                             write!(f, "{lt} ", lt = lt.print())?;
                         }
-                        write!(f, "{mutability}self", mutability = mutability.print_with_space())?;
+                        write!(f, "{mutability}self", mutability = mutability.print_with_space())
                     }
                     _ => {
-                        write!(f, "self: ")?;
-                        selfty.print(cx).fmt(f)?;
+                        f.write_str("self: ")?;
+                        self_ty.print(cx).fmt(f)
                     }
                 }
             } else {
@@ -1368,28 +1350,55 @@ impl clean::FnDecl {
                 if let Some(name) = param.name {
                     write!(f, "{name}: ")?;
                 }
-                param.type_.print(cx).fmt(f)?;
+                param.type_.print(cx).fmt(f)
             }
-            match (line_wrapping_indent, last_input_index) {
-                (_, None) => (),
-                (None, Some(last_i)) if i != last_i => write!(f, ", ")?,
-                (None, Some(_)) => (),
-                (Some(n), Some(last_i)) if i != last_i => write!(f, ",\n{}", Indent(n + 4))?,
-                (Some(_), Some(_)) => writeln!(f, ",")?,
+        })
+    }
+
+    fn inner_full_print(
+        &self,
+        // For None, the declaration will not be line-wrapped. For Some(n),
+        // the declaration will be line-wrapped, with an indent of n spaces.
+        line_wrapping_indent: Option<usize>,
+        f: &mut fmt::Formatter<'_>,
+        cx: &Context<'_>,
+    ) -> fmt::Result {
+        f.write_char('(')?;
+
+        if !self.inputs.is_empty() {
+            let line_wrapping_indent = line_wrapping_indent.map(|n| Indent(n + 4));
+
+            if let Some(indent) = line_wrapping_indent {
+                write!(f, "\n{indent}")?;
+            }
+
+            let sep = fmt::from_fn(|f| {
+                if let Some(indent) = line_wrapping_indent {
+                    write!(f, ",\n{indent}")
+                } else {
+                    f.write_str(", ")
+                }
+            });
+
+            self.inputs.iter().map(|param| Self::print_param(param, cx)).joined(sep, f)?;
+
+            if line_wrapping_indent.is_some() {
+                writeln!(f, ",")?
+            }
+
+            if self.c_variadic {
+                match line_wrapping_indent {
+                    None => write!(f, ", ...")?,
+                    Some(indent) => writeln!(f, "{indent}...")?,
+                };
             }
         }
 
-        if self.c_variadic {
-            match line_wrapping_indent {
-                None => write!(f, ", ...")?,
-                Some(n) => writeln!(f, "{}...", Indent(n + 4))?,
-            };
+        if let Some(n) = line_wrapping_indent {
+            write!(f, "{}", Indent(n))?
         }
 
-        match line_wrapping_indent {
-            None => write!(f, ")")?,
-            Some(n) => write!(f, "{})", Indent(n))?,
-        };
+        f.write_char(')')?;
 
         self.print_output(cx).fmt(f)
     }