Make more functions return fmt::Result and reduce number of .unwrap() calls

Author: GuillaumeGomez

src/librustdoc/html/format.rs

@@ -1252,9 +1252,9 @@ struct Indent(usize);
 
 impl Display for Indent {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        (0..self.0).for_each(|_| {
-            f.write_char(' ').unwrap();
-        });
+        for _ in 0..self.0 {
+            f.write_char(' ')?;
+        }
         Ok(())
     }
 }

src/librustdoc/html/length_limit.rs

@@ -1,6 +1,6 @@
 //! See [`HtmlWithLimit`].
 
-use std::fmt::Write;
+use std::fmt::{self, Write};
 use std::ops::ControlFlow;
 
 use crate::html::escape::Escape;
@@ -51,7 +51,7 @@ impl HtmlWithLimit {
     /// Finish using the buffer and get the written output.
     /// This function will close all unclosed tags for you.
     pub(super) fn finish(mut self) -> String {
-        self.close_all_tags();
+        self.close_all_tags().unwrap();
         self.buf
     }
 
@@ -64,7 +64,7 @@ impl HtmlWithLimit {
             return ControlFlow::Break(());
         }
 
-        self.flush_queue();
+        self.flush_queue().unwrap();
         write!(self.buf, "{}", Escape(text)).unwrap();
         self.len += text.len();
 
@@ -84,32 +84,35 @@ impl HtmlWithLimit {
     }
 
     /// Close the most recently opened HTML tag.
-    pub(super) fn close_tag(&mut self) {
+    pub(super) fn close_tag(&mut self) -> fmt::Result {
         if let Some(tag_name) = self.unclosed_tags.pop() {
             // Close the most recently opened tag.
-            write!(self.buf, "</{tag_name}>").unwrap()
+            write!(self.buf, "</{tag_name}>")?
         }
         // There are valid cases where `close_tag()` is called without
         // there being any tags to close. For example, this occurs when
         // a tag is opened after the length limit is exceeded;
         // `flush_queue()` will never be called, and thus, the tag will
         // not end up being added to `unclosed_tags`.
+        Ok(())
     }
 
     /// Write all queued tags and add them to the `unclosed_tags` list.
-    fn flush_queue(&mut self) {
+    fn flush_queue(&mut self) -> fmt::Result {
         for tag_name in self.queued_tags.drain(..) {
-            write!(self.buf, "<{tag_name}>").unwrap();
+            write!(self.buf, "<{tag_name}>")?;
 
             self.unclosed_tags.push(tag_name);
         }
+        Ok(())
     }
 
     /// Close all unclosed tags.
-    fn close_all_tags(&mut self) {
+    fn close_all_tags(&mut self) -> fmt::Result {
         while !self.unclosed_tags.is_empty() {
-            self.close_tag();
+            self.close_tag()?;
         }
+        Ok(())
     }
 }
 

src/librustdoc/html/length_limit/tests.rs

@@ -12,7 +12,7 @@ fn basic() {
     let _ = buf.push("Hello ");
     buf.open_tag("em");
     let _ = buf.push("world");
-    buf.close_tag();
+    buf.close_tag().unwrap();
     let _ = buf.push("!");
     assert_eq!(buf.finish(), "Hello <em>world</em>!");
 }
@@ -31,7 +31,7 @@ fn limit_0() {
     let _ = buf.push("Hello ");
     buf.open_tag("em");
     let _ = buf.push("world");
-    buf.close_tag();
+    buf.close_tag().unwrap();
     let _ = buf.push("!");
     assert_eq!(buf.finish(), "");
 }
@@ -42,7 +42,7 @@ fn exactly_limit() {
     let _ = buf.push("Hello ");
     buf.open_tag("em");
     let _ = buf.push("world");
-    buf.close_tag();
+    buf.close_tag().unwrap();
     let _ = buf.push("!");
     assert_eq!(buf.finish(), "Hello <em>world</em>!");
 }
@@ -56,9 +56,9 @@ fn multiple_nested_tags() {
     let _ = buf.push("paragraph");
     buf.open_tag("strong");
     let _ = buf.push("!");
-    buf.close_tag();
-    buf.close_tag();
-    buf.close_tag();
+    buf.close_tag().unwrap();
+    buf.close_tag().unwrap();
+    buf.close_tag().unwrap();
     assert_eq!(buf.finish(), "<p>This is a <em>paragraph<strong>!</strong></em></p>");
 }
 
@@ -82,10 +82,10 @@ fn past_the_limit() {
         buf.open_tag("strong");
         let _ = buf.push("word#")?;
         let _ = buf.push(&n.to_string())?;
-        buf.close_tag();
+        buf.close_tag().unwrap();
         ControlFlow::Continue(())
     });
-    buf.close_tag();
+    buf.close_tag().unwrap();
     assert_eq!(
         buf.finish(),
         "<p>\
@@ -111,10 +111,10 @@ fn close_too_many() {
     let mut buf = HtmlWithLimit::new(60);
     buf.open_tag("p");
     let _ = buf.push("Hello");
-    buf.close_tag();
+    buf.close_tag().unwrap();
     // This call does not panic because there are valid cases
     // where `close_tag()` is called with no tags left to close.
     // So `close_tag()` does nothing in this case.
-    buf.close_tag();
+    buf.close_tag().unwrap();
     assert_eq!(buf.finish(), "<p>Hello</p>");
 }

src/librustdoc/html/markdown.rs

@@ -1570,7 +1570,7 @@ fn markdown_summary_with_limit(
                 if r.is_break() {
                     stopped_early = true;
                 } else {
-                    buf.close_tag();
+                    buf.close_tag().unwrap();
                 }
                 return r;
             }
@@ -1581,7 +1581,7 @@ fn markdown_summary_with_limit(
                 _ => {}
             },
             Event::End(tag) => match tag {
-                TagEnd::Emphasis | TagEnd::Strong => buf.close_tag(),
+                TagEnd::Emphasis | TagEnd::Strong => buf.close_tag().unwrap(),
                 TagEnd::Paragraph | TagEnd::Heading(_) => return ControlFlow::Break(()),
                 _ => {}
             },