Pull out more types from html

[rust.git] / src / librustdoc / formats / mod.rs

diff --git a/src/librustdoc/formats/mod.rs b/src/librustdoc/formats/mod.rs
index 55827f473858aab02097685c3e309f0b9276fb08..97e1af13b8a56fa6ab63a95fe51dc80e5d90601c 100644 (file)
--- a/src/librustdoc/formats/mod.rs
+++ b/src/librustdoc/formats/mod.rs
@@ -1,107 +1,40 @@
-use std::cell::RefCell;
-use std::rc::Rc;
+pub mod cache;
+pub mod item_type;
+pub mod renderer;
 
-use rustc_span::edition::Edition;
+pub use renderer::{FormatRenderer, Renderer};
 
-use crate::clean;
-use crate::config::{RenderInfo, RenderOptions};
-use crate::error::Error;
-
-pub trait FormatRenderer: Clone {
-    type Output: FormatRenderer;
-
-    fn init(
-        krate: clean::Crate,
-        options: RenderOptions,
-        renderinfo: RenderInfo,
-        diag: &rustc_errors::Handler,
-        edition: Edition,
-        parent: Rc<RefCell<Renderer>>,
-    ) -> Result<(Self::Output, clean::Crate), Error>;
-
-    /// Renders a single non-module item. This means no recursive sub-item rendering is required.
-    fn item(&mut self, item: clean::Item) -> Result<(), Error>;
+use rustc_span::def_id::DefId;
 
-    /// Renders a module. Doesn't need to handle recursing into children, the driver does that
-    /// automatically.
-    fn mod_item_in(
-        &mut self,
-        item: &clean::Item,
-        item_name: &str,
-        module: &clean::Module,
-    ) -> Result<(), Error>;
-
-    /// Runs after recursively rendering all sub-items of a module.
-    fn mod_item_out(&mut self) -> Result<(), Error>;
-
-    /// Post processing hook for cleanup and dumping output to files.
-    fn after_krate(&mut self, krate: &clean::Crate) -> Result<(), Error>;
+use crate::clean;
+use crate::clean::types::GetDefId;
 
-    /// Called after everything else to write out errors.
-    fn after_run(&mut self, diag: &rustc_errors::Handler) -> Result<(), Error>;
+pub enum AssocItemRender<'a> {
+    All,
+    DerefFor { trait_: &'a clean::Type, type_: &'a clean::Type, deref_mut_: bool },
 }
 
-#[derive(Clone)]
-pub struct Renderer;
-
-impl Renderer {
-    pub fn new() -> Renderer {
-        Renderer
-    }
-
-    /// Main method for rendering a crate.
-    pub fn run<T: FormatRenderer + Clone>(
-        self,
-        krate: clean::Crate,
-        options: RenderOptions,
-        renderinfo: RenderInfo,
-        diag: &rustc_errors::Handler,
-        edition: Edition,
-    ) -> Result<(), Error> {
-        let rself = Rc::new(RefCell::new(self));
-        let (mut renderer, mut krate) =
-            T::init(krate, options, renderinfo, diag, edition, rself.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![(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");
-                }
+#[derive(Copy, Clone, PartialEq)]
+pub enum RenderMode {
+    Normal,
+    ForDeref { mut_: bool },
+}
 
-                let module = match item.inner {
-                    clean::StrippedItem(box clean::ModuleItem(ref m))
-                    | clean::ModuleItem(ref m) => m,
-                    _ => unreachable!(),
-                };
-                cx.mod_item_in(&item, &name, module)?;
-                let module = match item.inner {
-                    clean::StrippedItem(box clean::ModuleItem(m)) | clean::ModuleItem(m) => m,
-                    _ => unreachable!(),
-                };
-                for it in module.items {
-                    info!("Adding {:?} to worklist", it.name);
-                    work.push((cx.clone(), it));
-                }
+/// Metadata about implementations for a type or trait.
+#[derive(Clone, Debug)]
+pub struct Impl {
+    pub impl_item: clean::Item,
+}
 
-                cx.mod_item_out()?;
-            } else if item.name.is_some() {
-                cx.item(item)?;
-            }
+impl Impl {
+    pub fn inner_impl(&self) -> &clean::Impl {
+        match self.impl_item.inner {
+            clean::ImplItem(ref impl_) => impl_,
+            _ => panic!("non-impl item found in impl"),
         }
+    }
 
-        renderer.after_krate(&krate)?;
-        renderer.after_run(diag)
+    pub fn trait_did(&self) -> Option<DefId> {
+        self.inner_impl().trait_.def_id()
     }
 }