More requested changes

src/librustdoc/core.rs

@@ -44,9 +44,9 @@ pub type ExternalPaths = FxHashMap<DefId, (Vec<String>, clean::TypeKind)>;
 pub struct DocContext<'tcx> {
     pub tcx: TyCtxt<'tcx>,
     pub resolver: Rc<RefCell<interface::BoxedResolver>>,
-    /// Later on moved into `formats::cache::CACHE_KEY`
+    /// Later on moved into `CACHE_KEY`
     pub renderinfo: RefCell<RenderInfo>,
-    /// Later on moved through `clean::Crate` into `formats::cache::CACHE_KEY`
+    /// Later on moved through `clean::Crate` into `CACHE_KEY`
     pub external_traits: Rc<RefCell<FxHashMap<DefId, clean::Trait>>>,
     /// Used while populating `external_traits` to ensure we don't process the same trait twice at
     /// the same time.

src/librustdoc/formats/cache.rs

@@ -148,29 +148,19 @@ impl Cache {
             external_paths.into_iter().map(|(k, (v, t))| (k, (v, ItemType::from(t)))).collect();
 
         let mut cache = Cache {
-            impls: Default::default(),
             external_paths,
             exact_paths,
-            paths: Default::default(),
-            implementors: Default::default(),
-            stack: Vec::new(),
-            parent_stack: Vec::new(),
-            search_index: Vec::new(),
             parent_is_trait_impl: false,
-            extern_locations: Default::default(),
-            primitive_locations: Default::default(),
             stripped_mod: false,
             access_levels,
             crate_version: krate.version.take(),
             document_private,
-            orphan_impl_items: Vec::new(),
-            orphan_trait_impls: Vec::new(),
             traits: krate.external_traits.replace(Default::default()),
             deref_trait_did,
             deref_mut_trait_did,
             owned_box_did,
             masked_crates: mem::take(&mut krate.masked_crates),
-            aliases: Default::default(),
+            ..Cache::default()
         };
 
         // Cache where all our extern crates are located
@@ -211,7 +201,7 @@ impl Cache {
         for (trait_did, dids, impl_) in cache.orphan_trait_impls.drain(..) {
             if cache.traits.contains_key(&trait_did) {
                 for did in dids {
-                    cache.impls.entry(did).or_insert(vec![]).push(impl_.clone());
+                    cache.impls.entry(did).or_default().push(impl_.clone());
                 }
             }
         }

src/librustdoc/formats/mod.rs

@@ -2,7 +2,7 @@ pub mod cache;
 pub mod item_type;
 pub mod renderer;
 
-pub use renderer::{FormatRenderer, Renderer};
+pub use renderer::{run_format, FormatRenderer};
 
 use rustc_span::def_id::DefId;
 

src/librustdoc/formats/renderer.rs

@@ -7,7 +7,7 @@ use crate::config::{RenderInfo, RenderOptions};
 use crate::error::Error;
 use crate::formats::cache::{Cache, CACHE_KEY};
 
-/// Allows for different backends to rustdoc to be used with the `Renderer::run()` function. Each
+/// Allows for different backends to rustdoc to be used with the `run_format()` function. Each
 /// backend renderer has hooks for initialization, documenting an item, entering and exiting a
 /// module, and cleanup/finalizing output.
 pub trait FormatRenderer: Clone {
@@ -42,75 +42,65 @@ pub trait FormatRenderer: Clone {
     fn after_run(&mut self, diag: &rustc_errors::Handler) -> Result<(), Error>;
 }
 
-#[derive(Clone)]
-pub struct Renderer;
-
-impl Renderer {
-    pub fn new() -> Renderer {
-        Renderer
-    }
+/// Main method for rendering a crate.
+pub fn run_format<T: FormatRenderer>(
+    krate: clean::Crate,
+    options: RenderOptions,
+    render_info: RenderInfo,
+    diag: &rustc_errors::Handler,
+    edition: Edition,
+) -> Result<(), Error> {
+    let (krate, mut cache) = Cache::from_krate(
+        render_info.clone(),
+        options.document_private,
+        &options.extern_html_root_urls,
+        &options.output,
+        krate,
+    );
+
+    let (mut format_renderer, mut krate) =
+        T::init(krate, options, render_info, edition, &mut cache)?;
+
+    let cache = Arc::new(cache);
+    // Freeze the cache now that the index has been built. Put an Arc into TLS for future
+    // parallelization opportunities
+    CACHE_KEY.with(|v| *v.borrow_mut() = cache.clone());
+
+    let mut item = match krate.module.take() {
+        Some(i) => i,
+        None => return Ok(()),
+    };
+
+    item.name = Some(krate.name.clone());
+
+    // Render the crate documentation
+    let mut work = vec![(format_renderer.clone(), item)];
+
+    while let Some((mut cx, item)) = work.pop() {
+        if item.is_mod() {
+            // modules are special because they add a namespace. We also need to
+            // recurse into the items of the module as well.
+            let name = item.name.as_ref().unwrap().to_string();
+            if name.is_empty() {
+                panic!("Unexpected module with empty name");
+            }
 
-    /// Main method for rendering a crate.
-    pub fn run<T: FormatRenderer + Clone>(
-        self,
-        krate: clean::Crate,
-        options: RenderOptions,
-        render_info: RenderInfo,
-        diag: &rustc_errors::Handler,
-        edition: Edition,
-    ) -> Result<(), Error> {
-        let (krate, mut cache) = Cache::from_krate(
-            render_info.clone(),
-            options.document_private,
-            &options.extern_html_root_urls,
-            &options.output,
-            krate,
-        );
-
-        let (mut format_renderer, mut krate) =
-            T::init(krate, options, render_info, edition, &mut cache)?;
-
-        let cache = Arc::new(cache);
-        // Freeze the cache now that the index has been built. Put an Arc into TLS for future
-        // parallelization opportunities
-        CACHE_KEY.with(|v| *v.borrow_mut() = cache.clone());
-
-        let mut item = match krate.module.take() {
-            Some(i) => i,
-            None => return Ok(()),
-        };
-
-        item.name = Some(krate.name.clone());
-
-        // Render the crate documentation
-        let mut work = vec![(format_renderer.clone(), item)];
-
-        while let Some((mut cx, item)) = work.pop() {
-            if item.is_mod() {
-                // modules are special because they add a namespace. We also need to
-                // recurse into the items of the module as well.
-                let name = item.name.as_ref().unwrap().to_string();
-                if name.is_empty() {
-                    panic!("Unexpected module with empty name");
-                }
-
-                cx.mod_item_in(&item, &name, &cache)?;
-                let module = match item.inner {
-                    clean::StrippedItem(box clean::ModuleItem(m)) | clean::ModuleItem(m) => m,
-                    _ => unreachable!(),
-                };
-                for it in module.items {
-                    debug!("Adding {:?} to worklist", it.name);
-                    work.push((cx.clone(), it));
-                }
-
-                cx.mod_item_out(&name)?;
-            } else if item.name.is_some() {
-                cx.item(item, &cache)?;
+            cx.mod_item_in(&item, &name, &cache)?;
+            let module = match item.inner {
+                clean::StrippedItem(box clean::ModuleItem(m)) | clean::ModuleItem(m) => m,
+                _ => unreachable!(),
+            };
+            for it in module.items {
+                debug!("Adding {:?} to worklist", it.name);
+                work.push((cx.clone(), it));
             }
-        }
 
-        format_renderer.after_krate(&krate, &cache)?;
-        format_renderer.after_run(diag)
+            cx.mod_item_out(&name)?;
+        } else if item.name.is_some() {
+            cx.item(item, &cache)?;
+        }
     }
+
+    format_renderer.after_krate(&krate, &cache)?;
+    format_renderer.after_run(diag)
 }

src/librustdoc/html/render/mod.rs

@@ -228,7 +228,7 @@ impl Serialize for IndexItem {
 
 /// A type used for the search index.
 #[derive(Debug)]
-pub struct RenderType {
+crate struct RenderType {
     ty: Option<DefId>,
     idx: Option<usize>,
     name: Option<String>,
@@ -259,7 +259,7 @@ impl Serialize for RenderType {
 
 /// A type used for the search index.
 #[derive(Debug)]
-pub struct Generic {
+crate struct Generic {
     name: String,
     defid: Option<DefId>,
     idx: Option<usize>,
@@ -313,7 +313,7 @@ impl Serialize for IndexItemFunctionType {
 }
 
 #[derive(Debug)]
-pub struct TypeWithKind {
+crate struct TypeWithKind {
     ty: RenderType,
     kind: TypeKind,
 }

src/librustdoc/lib.rs

@@ -502,9 +502,9 @@ fn main_options(options: config::Options) -> i32 {
         info!("going to format");
         let (error_format, edition, debugging_options) = diag_opts;
         let diag = core::new_handler(error_format, None, &debugging_options);
-        match formats::Renderer::new()
-            .run::<html::render::Context>(krate, renderopts, renderinfo, &diag, edition)
-        {
+        match formats::run_format::<html::render::Context>(
+            krate, renderopts, renderinfo, &diag, edition,
+        ) {
             Ok(_) => rustc_driver::EXIT_SUCCESS,
             Err(e) => {
                 diag.struct_err(&format!("couldn't generate documentation: {}", e.error))