Create buffers in top-level rendering

Mark-Simulacrum · Mark-Simulacrum · commit 9e52ba94faa4 · 2019-09-07T19:31:58.000-04:00
This avoids needlessly creating and threading the buffers through when
we only use them once.
diff --git a/src/librustdoc/html/layout.rs b/src/librustdoc/html/layout.rs
@@ -26,15 +26,15 @@ pub struct Page<'a> {
 }
 
 pub fn render<T: fmt::Display, S: fmt::Display>(
-    dst: &mut Buffer,
     layout: &Layout,
     page: &Page<'_>,
     sidebar: &S,
     t: &T,
     css_file_extension: bool,
     themes: &[PathBuf],
     generate_search_filter: bool,
-) {
+) -> String {
+    let mut dst = Buffer::html();
     let static_root_path = page.static_root_path.unwrap_or(page.root_path);
     write!(dst,
 "<!DOCTYPE html>\
@@ -235,12 +235,13 @@ pub fn render<T: fmt::Display, S: fmt::Display>(
     } else {
         ""
     },
-    )
+    );
+    dst.into_inner()
 }
 
-pub fn redirect(dst: &mut Buffer, url: &str) {
+pub fn redirect(url: &str) -> String {
     // <script> triggers a redirect before refresh, so this is fine.
-    write!(dst,
+    format!(
 r##"<!DOCTYPE html>
 <html lang="en">
 <head>
diff --git a/src/librustdoc/html/render.rs b/src/librustdoc/html/render.rs
@@ -65,7 +65,7 @@ use crate::docfs::{DocFS, ErrorStorage, PathError};
 use crate::doctree;
 use crate::fold::DocFolder;
 use crate::html::escape::Escape;
-use crate::html::format::{Buffer, AsyncSpace, ConstnessSpace};
+use crate::html::format::{AsyncSpace, ConstnessSpace};
 use crate::html::format::{GenericBounds, WhereClause, href, AbiSpace, DefaultSpace};
 use crate::html::format::{VisSpace, Function, UnsafetySpace, MutableSpace};
 use crate::html::format::fmt_impl_for_trait_page;
@@ -1185,13 +1185,12 @@ themePicker.onblur = handleThemeButtonsBlur;
                                                 SlashChecker(s), s)
                                     })
                                     .collect::<String>());
-            let mut v = Buffer::html();
-            layout::render(&mut v, &cx.shared.layout,
+            let v = layout::render(&cx.shared.layout,
                            &page, &(""), &content,
                            cx.shared.css_file_extension.is_some(),
                            &cx.shared.themes,
                            cx.shared.generate_search_filter);
-            cx.shared.fs.write(&dst, v.into_inner().as_bytes())?;
+            cx.shared.fs.write(&dst, v.as_bytes())?;
         }
     }
 
@@ -1939,13 +1938,12 @@ impl Context {
         } else {
             String::new()
         };
-        let mut v = Buffer::html();
-        layout::render(&mut v, &self.shared.layout,
+        let v = layout::render(&self.shared.layout,
                        &page, &sidebar, &all,
                        self.shared.css_file_extension.is_some(),
                        &self.shared.themes,
                        self.shared.generate_search_filter);
-        self.shared.fs.write(&final_file, v.into_inner().as_bytes())?;
+        self.shared.fs.write(&final_file, v.as_bytes())?;
 
         // Generating settings page.
         let settings = Settings::new(self.shared.static_root_path.as_deref().unwrap_or("./"),
@@ -1958,24 +1956,21 @@ impl Context {
         let sidebar = "<p class='location'>Settings</p><div class='sidebar-elems'></div>";
         themes.push(PathBuf::from("settings.css"));
         let layout = self.shared.layout.clone();
-        let mut v = Buffer::html();
-        layout::render(
-            &mut v,
+        let v = layout::render(
             &layout,
             &page, &sidebar, &settings,
             self.shared.css_file_extension.is_some(),
             &themes,
             self.shared.generate_search_filter,
         );
-        self.shared.fs.write(&settings_file, v.into_inner().as_bytes())?;
+        self.shared.fs.write(&settings_file, v.as_bytes())?;
 
         Ok(())
     }
 
     fn render_item(&self,
-                   writer: &mut Buffer,
                    it: &clean::Item,
-                   pushname: bool) {
+                   pushname: bool) -> String {
         // A little unfortunate that this is done like this, but it sure
         // does make formatting *a lot* nicer.
         CURRENT_DEPTH.with(|slot| {
@@ -2022,12 +2017,12 @@ impl Context {
         }
 
         if !self.render_redirect_pages {
-            layout::render(writer, &self.shared.layout, &page,
+            layout::render(&self.shared.layout, &page,
                            &Sidebar{ cx: self, item: it },
                            &Item{ cx: self, item: it },
                            self.shared.css_file_extension.is_some(),
                            &self.shared.themes,
-                           self.shared.generate_search_filter);
+                           self.shared.generate_search_filter)
         } else {
             let mut url = self.root_path();
             if let Some(&(ref names, ty)) = cache().paths.get(&it.def_id) {
@@ -2036,7 +2031,9 @@ impl Context {
                     url.push_str("/");
                 }
                 url.push_str(&item_path(ty, names.last().unwrap()));
-                layout::redirect(writer, &url);
+                layout::redirect(&url)
+            } else {
+                String::new()
             }
         }
     }
@@ -2074,13 +2071,12 @@ impl Context {
 
             info!("Recursing into {}", self.dst.display());
 
-            let mut buf = Buffer::html();
-            self.render_item(&mut buf, &item, false);
+            let buf = self.render_item(&item, false);
             // buf will be empty if the module is stripped and there is no redirect for it
             if !buf.is_empty() {
                 self.shared.ensure_dir(&self.dst)?;
                 let joint_dst = self.dst.join("index.html");
-                scx.fs.write(&joint_dst, buf.into_inner().as_bytes())?;
+                scx.fs.write(&joint_dst, buf.as_bytes())?;
             }
 
             let m = match item.inner {
@@ -2109,16 +2105,15 @@ impl Context {
             self.dst = prev;
             self.current.pop().unwrap();
         } else if item.name.is_some() {
-            let mut buf = Buffer::html();
-            self.render_item(&mut buf, &item, true);
+            let buf = self.render_item(&item, true);
             // buf will be empty if the item is stripped and there is no redirect for it
             if !buf.is_empty() {
                 let name = item.name.as_ref().unwrap();
                 let item_type = item.type_();
                 let file_name = &item_path(item_type, name);
                 self.shared.ensure_dir(&self.dst)?;
                 let joint_dst = self.dst.join(file_name);
-                self.shared.fs.write(&joint_dst, buf.into_inner().as_bytes())?;
+                self.shared.fs.write(&joint_dst, buf.as_bytes())?;
 
                 if !self.render_redirect_pages {
                     all.append(full_path(self, &item), &item_type);
@@ -2128,18 +2123,16 @@ impl Context {
                     // URL for the page.
                     let redir_name = format!("{}.{}.html", name, item_type.name_space());
                     let redir_dst = self.dst.join(redir_name);
-                    let mut v = Buffer::html();
-                    layout::redirect(&mut v, file_name);
-                    self.shared.fs.write(&redir_dst, v.into_inner().as_bytes())?;
+                    let v = layout::redirect(file_name);
+                    self.shared.fs.write(&redir_dst, v.as_bytes())?;
                 }
                 // If the item is a macro, redirect from the old macro URL (with !)
                 // to the new one (without).
                 if item_type == ItemType::Macro {
                     let redir_name = format!("{}.{}!.html", item_type, name);
                     let redir_dst = self.dst.join(redir_name);
-                    let mut v = Buffer::html();
-                    layout::redirect(&mut v, file_name);
-                    self.shared.fs.write(&redir_dst, v.into_inner().as_bytes())?;
+                    let v = layout::redirect(file_name);
+                    self.shared.fs.write(&redir_dst, v.as_bytes())?;
                 }
             }
         }
diff --git a/src/librustdoc/html/sources.rs b/src/librustdoc/html/sources.rs
@@ -4,7 +4,6 @@ use crate::fold::DocFolder;
 use crate::html::layout;
 use crate::html::render::{Error, SharedContext, BASIC_KEYWORDS};
 use crate::html::highlight;
-use crate::html::format::Buffer;
 use std::ffi::OsStr;
 use std::fs;
 use std::path::{Component, Path, PathBuf};
@@ -106,7 +105,6 @@ impl<'a> SourceCollector<'a> {
         cur.push(&fname);
         href.push_str(&fname.to_string_lossy());
 
-        let mut v = Buffer::html();
         let title = format!("{} -- source", cur.file_name().expect("failed to get file name")
                                                .to_string_lossy());
         let desc = format!("Source to the Rust file `{}`.", filename);
@@ -121,12 +119,12 @@ impl<'a> SourceCollector<'a> {
             extra_scripts: &[&format!("source-files{}", self.scx.resource_suffix)],
             static_extra_scripts: &[&format!("source-script{}", self.scx.resource_suffix)],
         };
-        layout::render(&mut v, &self.scx.layout,
+        let v = layout::render(&self.scx.layout,
                        &page, &(""), &Source(contents),
                        self.scx.css_file_extension.is_some(),
                        &self.scx.themes,
                        self.scx.generate_search_filter);
-        self.scx.fs.write(&cur, v.into_inner().as_bytes())?;
+        self.scx.fs.write(&cur, v.as_bytes())?;
         self.scx.local_sources.insert(p.clone(), href);
         Ok(())
     }
