Adding upstream version 1.64.0+dfsg1.upstream/1.64.0+dfsg1

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

76 files changed, 22160 insertions, 0 deletions

diff --git a/src/librustdoc/html/escape.rs b/src/librustdoc/html/escape.rs
new file mode 100644
index 000000000..4a19d0a44
--- /dev/null
+++ b/src/librustdoc/html/escape.rs
@@ -0,0 +1,40 @@
+//! HTML escaping.
+//!
+//! This module contains one unit struct, which can be used to HTML-escape a
+//! string of text (for use in a format string).
+
+use std::fmt;
+
+/// Wrapper struct which will emit the HTML-escaped version of the contained
+/// string when passed to a format string.
+pub(crate) struct Escape<'a>(pub &'a str);
+
+impl<'a> fmt::Display for Escape<'a> {
+    fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+        // Because the internet is always right, turns out there's not that many
+        // characters to escape: http://stackoverflow.com/questions/7381974
+        let Escape(s) = *self;
+        let pile_o_bits = s;
+        let mut last = 0;
+        for (i, ch) in s.char_indices() {
+            let s = match ch {
+                '>' => "&gt;",
+                '<' => "&lt;",
+                '&' => "&amp;",
+                '\'' => "&#39;",
+                '"' => "&quot;",
+                _ => continue,
+            };
+            fmt.write_str(&pile_o_bits[last..i])?;
+            fmt.write_str(s)?;
+            // NOTE: we only expect single byte characters here - which is fine as long as we
+            // only match single byte characters
+            last = i + 1;
+        }
+
+        if last < s.len() {
+            fmt.write_str(&pile_o_bits[last..])?;
+        }
+        Ok(())
+    }
+}
diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs
new file mode 100644
index 000000000..36a47b05c
--- /dev/null
+++ b/src/librustdoc/html/format.rs
@@ -0,0 +1,1688 @@
+//! HTML formatting module
+//!
+//! This module contains a large number of `fmt::Display` implementations for
+//! various types in `rustdoc::clean`. These implementations all currently
+//! assume that HTML output is desired, although it may be possible to redesign
+//! them in the future to instead emit any format desired.
+
+use std::borrow::Cow;
+use std::cell::Cell;
+use std::fmt;
+use std::iter::{self, once};
+
+use rustc_ast as ast;
+use rustc_attr::{ConstStability, StabilityLevel};
+use rustc_data_structures::captures::Captures;
+use rustc_data_structures::fx::FxHashSet;
+use rustc_hir as hir;
+use rustc_hir::def::DefKind;
+use rustc_hir::def_id::DefId;
+use rustc_metadata::creader::{CStore, LoadedMacro};
+use rustc_middle::ty;
+use rustc_middle::ty::DefIdTree;
+use rustc_middle::ty::TyCtxt;
+use rustc_span::symbol::kw;
+use rustc_span::{sym, Symbol};
+use rustc_target::spec::abi::Abi;
+
+use itertools::Itertools;
+
+use crate::clean::{
+    self, types::ExternalLocation, utils::find_nearest_parent_module, ExternalCrate, ItemId,
+    PrimitiveType,
+};
+use crate::formats::item_type::ItemType;
+use crate::html::escape::Escape;
+use crate::html::render::Context;
+
+use super::url_parts_builder::estimate_item_path_byte_length;
+use super::url_parts_builder::UrlPartsBuilder;
+
+pub(crate) trait Print {
+    fn print(self, buffer: &mut Buffer);
+}
+
+impl<F> Print for F
+where
+    F: FnOnce(&mut Buffer),
+{
+    fn print(self, buffer: &mut Buffer) {
+        (self)(buffer)
+    }
+}
+
+impl Print for String {
+    fn print(self, buffer: &mut Buffer) {
+        buffer.write_str(&self);
+    }
+}
+
+impl Print for &'_ str {
+    fn print(self, buffer: &mut Buffer) {
+        buffer.write_str(self);
+    }
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct Buffer {
+    for_html: bool,
+    buffer: String,
+}
+
+impl core::fmt::Write for Buffer {
+    #[inline]
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        self.buffer.write_str(s)
+    }
+
+    #[inline]
+    fn write_char(&mut self, c: char) -> fmt::Result {
+        self.buffer.write_char(c)
+    }
+
+    #[inline]
+    fn write_fmt(&mut self, args: fmt::Arguments<'_>) -> fmt::Result {
+        self.buffer.write_fmt(args)
+    }
+}
+
+impl Buffer {
+    pub(crate) fn empty_from(v: &Buffer) -> Buffer {
+        Buffer { for_html: v.for_html, buffer: String::new() }
+    }
+
+    pub(crate) fn html() -> Buffer {
+        Buffer { for_html: true, buffer: String::new() }
+    }
+
+    pub(crate) fn new() -> Buffer {
+        Buffer { for_html: false, buffer: String::new() }
+    }
+
+    pub(crate) fn is_empty(&self) -> bool {
+        self.buffer.is_empty()
+    }
+
+    pub(crate) fn into_inner(self) -> String {
+        self.buffer
+    }
+
+    pub(crate) fn insert_str(&mut self, idx: usize, s: &str) {
+        self.buffer.insert_str(idx, s);
+    }
+
+    pub(crate) fn push_str(&mut self, s: &str) {
+        self.buffer.push_str(s);
+    }
+
+    pub(crate) fn push_buffer(&mut self, other: Buffer) {
+        self.buffer.push_str(&other.buffer);
+    }
+
+    // Intended for consumption by write! and writeln! (std::fmt) but without
+    // the fmt::Result return type imposed by fmt::Write (and avoiding the trait
+    // import).
+    pub(crate) fn write_str(&mut self, s: &str) {
+        self.buffer.push_str(s);
+    }
+
+    // Intended for consumption by write! and writeln! (std::fmt) but without
+    // the fmt::Result return type imposed by fmt::Write (and avoiding the trait
+    // import).
+    pub(crate) fn write_fmt(&mut self, v: fmt::Arguments<'_>) {
+        use fmt::Write;
+        self.buffer.write_fmt(v).unwrap();
+    }
+
+    pub(crate) fn to_display<T: Print>(mut self, t: T) -> String {
+        t.print(&mut self);
+        self.into_inner()
+    }
+
+    pub(crate) fn is_for_html(&self) -> bool {
+        self.for_html
+    }
+
+    pub(crate) fn reserve(&mut self, additional: usize) {
+        self.buffer.reserve(additional)
+    }
+
+    pub(crate) fn len(&self) -> usize {
+        self.buffer.len()
+    }
+}
+
+fn comma_sep<T: fmt::Display>(
+    items: impl Iterator<Item = T>,
+    space_after_comma: bool,
+) -> impl fmt::Display {
+    display_fn(move |f| {
+        for (i, item) in items.enumerate() {
+            if i != 0 {
+                write!(f, ",{}", if space_after_comma { " " } else { "" })?;
+            }
+            fmt::Display::fmt(&item, f)?;
+        }
+        Ok(())
+    })
+}
+
+pub(crate) fn print_generic_bounds<'a, 'tcx: 'a>(
+    bounds: &'a [clean::GenericBound],
+    cx: &'a Context<'tcx>,
+) -> impl fmt::Display + 'a + Captures<'tcx> {
+    display_fn(move |f| {
+        let mut bounds_dup = FxHashSet::default();
+
+        for (i, bound) in bounds.iter().filter(|b| bounds_dup.insert(b.clone())).enumerate() {
+            if i > 0 {
+                f.write_str(" + ")?;
+            }
+            fmt::Display::fmt(&bound.print(cx), f)?;
+        }
+        Ok(())
+    })
+}
+
+impl clean::GenericParamDef {
+    pub(crate) fn print<'a, 'tcx: 'a>(
+        &'a self,
+        cx: &'a Context<'tcx>,
+    ) -> impl fmt::Display + 'a + Captures<'tcx> {
+        display_fn(move |f| match &self.kind {
+            clean::GenericParamDefKind::Lifetime { outlives } => {
+                write!(f, "{}", self.name)?;
+
+                if !outlives.is_empty() {
+                    f.write_str(": ")?;
+                    for (i, lt) in outlives.iter().enumerate() {
+                        if i != 0 {
+                            f.write_str(" + ")?;
+                        }
+                        write!(f, "{}", lt.print())?;
+                    }
+                }
+
+                Ok(())
+            }
+            clean::GenericParamDefKind::Type { bounds, default, .. } => {
+                f.write_str(self.name.as_str())?;
+
+                if !bounds.is_empty() {
+                    if f.alternate() {
+                        write!(f, ": {:#}", print_generic_bounds(bounds, cx))?;
+                    } else {
+                        write!(f, ":&nbsp;{}", print_generic_bounds(bounds, cx))?;
+                    }
+                }
+
+                if let Some(ref ty) = default {
+                    if f.alternate() {
+                        write!(f, " = {:#}", ty.print(cx))?;
+                    } else {
+                        write!(f, "&nbsp;=&nbsp;{}", ty.print(cx))?;
+                    }
+                }
+
+                Ok(())
+            }
+            clean::GenericParamDefKind::Const { ty, default, .. } => {
+                if f.alternate() {
+                    write!(f, "const {}: {:#}", self.name, ty.print(cx))?;
+                } else {
+                    write!(f, "const {}:&nbsp;{}", self.name, ty.print(cx))?;
+                }
+
+                if let Some(default) = default {
+                    if f.alternate() {
+                        write!(f, " = {:#}", default)?;
+                    } else {
+                        write!(f, "&nbsp;=&nbsp;{}", default)?;
+                    }
+                }
+
+                Ok(())
+            }
+        })
+    }
+}
+
+impl clean::Generics {
+    pub(crate) fn print<'a, 'tcx: 'a>(
+        &'a self,
+        cx: &'a Context<'tcx>,
+    ) -> impl fmt::Display + 'a + Captures<'tcx> {
+        display_fn(move |f| {
+            let mut real_params =
+                self.params.iter().filter(|p| !p.is_synthetic_type_param()).peekable();
+            if real_params.peek().is_none() {
+                return Ok(());
+            }
+
+            if f.alternate() {
+                write!(f, "<{:#}>", comma_sep(real_params.map(|g| g.print(cx)), true))
+            } else {
+                write!(f, "&lt;{}&gt;", comma_sep(real_params.map(|g| g.print(cx)), true))
+            }
+        })
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+pub(crate) enum Ending {
+    Newline,
+    NoNewline,
+}
+
+/// * The Generics from which to emit a where-clause.
+/// * The number of spaces to indent each line with.
+/// * Whether the where-clause needs to add a comma and newline after the last bound.
+pub(crate) fn print_where_clause<'a, 'tcx: 'a>(
+    gens: &'a clean::Generics,
+    cx: &'a Context<'tcx>,
+    indent: usize,
+    ending: Ending,
+) -> impl fmt::Display + 'a + Captures<'tcx> {
+    use fmt::Write;
+
+    display_fn(move |f| {
+        let mut where_predicates = gens.where_predicates.iter().filter(|pred| {
+            !matches!(pred, clean::WherePredicate::BoundPredicate { bounds, .. } if bounds.is_empty())
+        }).map(|pred| {
+            display_fn(move |f| {
+                if f.alternate() {
+                    f.write_str(" ")?;
+                } else {
+                    f.write_str("<br>")?;
+                }
+
+                match pred {
+                    clean::WherePredicate::BoundPredicate { ty, bounds, bound_params } => {
+                        let ty_cx = ty.print(cx);
+                        let generic_bounds = print_generic_bounds(bounds, cx);
+
+                        if bound_params.is_empty() {
+                            if f.alternate() {
+                                write!(f, "{ty_cx:#}: {generic_bounds:#}")
+                            } else {
+                                write!(f, "{ty_cx}: {generic_bounds}")
+                            }
+                        } else {
+                            if f.alternate() {
+                                write!(
+                                    f,
+                                    "for<{:#}> {ty_cx:#}: {generic_bounds:#}",
+                                    comma_sep(bound_params.iter().map(|lt| lt.print()), true)
+                                )
+                            } else {
+                                write!(
+                                    f,
+                                    "for&lt;{}&gt; {ty_cx}: {generic_bounds}",
+                                    comma_sep(bound_params.iter().map(|lt| lt.print()), true)
+                                )
+                            }
+                        }
+                    }
+                    clean::WherePredicate::RegionPredicate { lifetime, bounds } => {
+                        let mut bounds_display = String::new();
+                        for bound in bounds.iter().map(|b| b.print(cx)) {
+                            write!(bounds_display, "{bound} + ")?;
+                        }
+                        bounds_display.truncate(bounds_display.len() - " + ".len());
+                        write!(f, "{}: {bounds_display}", lifetime.print())
+                    }
+                    clean::WherePredicate::EqPredicate { lhs, rhs } => {
+                        if f.alternate() {
+                            write!(f, "{:#} == {:#}", lhs.print(cx), rhs.print(cx))
+                        } else {
+                            write!(f, "{} == {}", lhs.print(cx), rhs.print(cx))
+                        }
+                    }
+                }
+            })
+        }).peekable();
+
+        if where_predicates.peek().is_none() {
+            return Ok(());
+        }
+
+        let where_preds = comma_sep(where_predicates, false);
+        let clause = if f.alternate() {
+            if ending == Ending::Newline {
+                // add a space so stripping <br> tags and breaking spaces still renders properly
+                format!(" where{where_preds}, ")
+            } else {
+                format!(" where{where_preds}")
+            }
+        } else {
+            let mut br_with_padding = String::with_capacity(6 * indent + 28);
+            br_with_padding.push_str("<br>");
+            for _ in 0..indent + 4 {
+                br_with_padding.push_str("&nbsp;");
+            }
+            let where_preds = where_preds.to_string().replace("<br>", &br_with_padding);
+
+            if ending == Ending::Newline {
+                let mut clause = "&nbsp;".repeat(indent.saturating_sub(1));
+                // add a space so stripping <br> tags and breaking spaces still renders properly
+                write!(
+                    clause,
+                    " <span class=\"where fmt-newline\">where{where_preds},&nbsp;</span>"
+                )?;
+                clause
+            } else {
+                // insert a <br> tag after a single space but before multiple spaces at the start
+                if indent == 0 {
+                    format!(" <br><span class=\"where\">where{where_preds}</span>")
+                } else {
+                    let mut clause = br_with_padding;
+                    clause.truncate(clause.len() - 5 * "&nbsp;".len());
+                    write!(clause, " <span class=\"where\">where{where_preds}</span>")?;
+                    clause
+                }
+            }
+        };
+        write!(f, "{clause}")
+    })
+}
+
+impl clean::Lifetime {
+    pub(crate) fn print(&self) -> impl fmt::Display + '_ {
+        self.0.as_str()
+    }
+}
+
+impl clean::Constant {
+    pub(crate) fn print(&self, tcx: TyCtxt<'_>) -> impl fmt::Display + '_ {
+        let expr = self.expr(tcx);
+        display_fn(
+            move |f| {
+                if f.alternate() { f.write_str(&expr) } else { write!(f, "{}", Escape(&expr)) }
+            },
+        )
+    }
+}
+
+impl clean::PolyTrait {
+    fn print<'a, 'tcx: 'a>(
+        &'a self,
+        cx: &'a Context<'tcx>,
+    ) -> impl fmt::Display + 'a + Captures<'tcx> {
+        display_fn(move |f| {
+            if !self.generic_params.is_empty() {
+                if f.alternate() {
+                    write!(
+                        f,
+                        "for<{:#}> ",
+                        comma_sep(self.generic_params.iter().map(|g| g.print(cx)), true)
+                    )?;
+                } else {
+                    write!(
+                        f,
+                        "for&lt;{}&gt; ",
+                        comma_sep(self.generic_params.iter().map(|g| g.print(cx)), true)
+                    )?;
+                }
+            }
+            if f.alternate() {
+                write!(f, "{:#}", self.trait_.print(cx))
+            } else {
+                write!(f, "{}", self.trait_.print(cx))
+            }
+        })
+    }
+}
+
+impl clean::GenericBound {
+    pub(crate) fn print<'a, 'tcx: 'a>(
+        &'a self,
+        cx: &'a Context<'tcx>,
+    ) -> impl fmt::Display + 'a + Captures<'tcx> {
+        display_fn(move |f| match self {
+            clean::GenericBound::Outlives(lt) => write!(f, "{}", lt.print()),
+            clean::GenericBound::TraitBound(ty, modifier) => {
+                let modifier_str = match modifier {
+                    hir::TraitBoundModifier::None => "",
+                    hir::TraitBoundModifier::Maybe => "?",
+                    // ~const is experimental; do not display those bounds in rustdoc
+                    hir::TraitBoundModifier::MaybeConst => "",
+                };
+                if f.alternate() {
+                    write!(f, "{}{:#}", modifier_str, ty.print(cx))
+                } else {
+                    write!(f, "{}{}", modifier_str, ty.print(cx))
+                }
+            }
+        })
+    }
+}
+
+impl clean::GenericArgs {
+    fn print<'a, 'tcx: 'a>(
+        &'a self,
+        cx: &'a Context<'tcx>,
+    ) -> impl fmt::Display + 'a + Captures<'tcx> {
+        display_fn(move |f| {
+            match self {
+                clean::GenericArgs::AngleBracketed { args, bindings } => {
+                    if !args.is_empty() || !bindings.is_empty() {
+                        if f.alternate() {
+                            f.write_str("<")?;
+                        } else {
+                            f.write_str("&lt;")?;
+                        }
+                        let mut comma = false;
+                        for arg in args.iter() {
+                            if comma {
+                                f.write_str(", ")?;
+                            }
+                            comma = true;
+                            if f.alternate() {
+                                write!(f, "{:#}", arg.print(cx))?;
+                            } else {
+                                write!(f, "{}", arg.print(cx))?;
+                            }
+                        }
+                        for binding in bindings.iter() {
+                            if comma {
+                                f.write_str(", ")?;
+                            }
+                            comma = true;
+                            if f.alternate() {
+                                write!(f, "{:#}", binding.print(cx))?;
+                            } else {
+                                write!(f, "{}", binding.print(cx))?;
+                            }
+                        }
+                        if f.alternate() {
+                            f.write_str(">")?;
+                        } else {
+                            f.write_str("&gt;")?;
+                        }
+                    }
+                }
+                clean::GenericArgs::Parenthesized { inputs, output } => {
+                    f.write_str("(")?;
+                    let mut comma = false;
+                    for ty in inputs.iter() {
+                        if comma {
+                            f.write_str(", ")?;
+                        }
+                        comma = true;
+                        if f.alternate() {
+                            write!(f, "{:#}", ty.print(cx))?;
+                        } else {
+                            write!(f, "{}", ty.print(cx))?;
+                        }
+                    }
+                    f.write_str(")")?;
+                    if let Some(ref ty) = *output {
+                        if f.alternate() {
+                            write!(f, " -> {:#}", ty.print(cx))?;
+                        } else {
+                            write!(f, " -&gt; {}", ty.print(cx))?;
+                        }
+                    }
+                }
+            }
+            Ok(())
+        })
+    }
+}
+
+// Possible errors when computing href link source for a `DefId`
+#[derive(PartialEq, Eq)]
+pub(crate) enum HrefError {
+    /// This item is known to rustdoc, but from a crate that does not have documentation generated.
+    ///
+    /// This can only happen for non-local items.
+    ///
+    /// # Example
+    ///
+    /// Crate `a` defines a public trait and crate `b` – the target crate that depends on `a` –
+    /// implements it for a local type.
+    /// We document `b` but **not** `a` (we only _build_ the latter – with `rustc`):
+    ///
+    /// ```sh
+    /// rustc a.rs --crate-type=lib
+    /// rustdoc b.rs --crate-type=lib --extern=a=liba.rlib
+    /// ```
+    ///
+    /// Now, the associated items in the trait impl want to link to the corresponding item in the
+    /// trait declaration (see `html::render::assoc_href_attr`) but it's not available since their
+    /// *documentation (was) not built*.
+    DocumentationNotBuilt,
+    /// This can only happen for non-local items when `--document-private-items` is not passed.
+    Private,
+    // Not in external cache, href link should be in same page
+    NotInExternalCache,
+}
+
+// Panics if `syms` is empty.
+pub(crate) fn join_with_double_colon(syms: &[Symbol]) -> String {
+    let mut s = String::with_capacity(estimate_item_path_byte_length(syms.len()));
+    s.push_str(syms[0].as_str());
+    for sym in &syms[1..] {
+        s.push_str("::");
+        s.push_str(sym.as_str());
+    }
+    s
+}
+
+/// This function is to get the external macro path because they are not in the cache used in
+/// `href_with_root_path`.
+fn generate_macro_def_id_path(
+    def_id: DefId,
+    cx: &Context<'_>,
+    root_path: Option<&str>,
+) -> Result<(String, ItemType, Vec<Symbol>), HrefError> {
+    let tcx = cx.shared.tcx;
+    let crate_name = tcx.crate_name(def_id.krate).to_string();
+    let cache = cx.cache();
+
+    let fqp: Vec<Symbol> = tcx
+        .def_path(def_id)
+        .data
+        .into_iter()
+        .filter_map(|elem| {
+            // extern blocks (and a few others things) have an empty name.
+            match elem.data.get_opt_name() {
+                Some(s) if !s.is_empty() => Some(s),
+                _ => None,
+            }
+        })
+        .collect();
+    let relative = fqp.iter().map(|elem| elem.to_string());
+    let cstore = CStore::from_tcx(tcx);
+    // We need this to prevent a `panic` when this function is used from intra doc links...
+    if !cstore.has_crate_data(def_id.krate) {
+        debug!("No data for crate {}", crate_name);
+        return Err(HrefError::NotInExternalCache);
+    }
+    // Check to see if it is a macro 2.0 or built-in macro.
+    // More information in <https://rust-lang.github.io/rfcs/1584-macros.html>.
+    let is_macro_2 = match cstore.load_macro_untracked(def_id, tcx.sess) {
+        LoadedMacro::MacroDef(def, _) => {
+            // If `ast_def.macro_rules` is `true`, then it's not a macro 2.0.
+            matches!(&def.kind, ast::ItemKind::MacroDef(ast_def) if !ast_def.macro_rules)
+        }
+        _ => false,
+    };
+
+    let mut path = if is_macro_2 {
+        once(crate_name.clone()).chain(relative).collect()
+    } else {
+        vec![crate_name.clone(), relative.last().unwrap()]
+    };
+    if path.len() < 2 {
+        // The minimum we can have is the crate name followed by the macro name. If shorter, then
+        // it means that that `relative` was empty, which is an error.
+        debug!("macro path cannot be empty!");
+        return Err(HrefError::NotInExternalCache);
+    }
+
+    if let Some(last) = path.last_mut() {
+        *last = format!("macro.{}.html", last);
+    }
+
+    let url = match cache.extern_locations[&def_id.krate] {
+        ExternalLocation::Remote(ref s) => {
+            // `ExternalLocation::Remote` always end with a `/`.
+            format!("{}{}", s, path.join("/"))
+        }
+        ExternalLocation::Local => {
+            // `root_path` always end with a `/`.
+            format!("{}{}/{}", root_path.unwrap_or(""), crate_name, path.join("/"))
+        }
+        ExternalLocation::Unknown => {
+            debug!("crate {} not in cache when linkifying macros", crate_name);
+            return Err(HrefError::NotInExternalCache);
+        }
+    };
+    Ok((url, ItemType::Macro, fqp))
+}
+
+pub(crate) fn href_with_root_path(
+    did: DefId,
+    cx: &Context<'_>,
+    root_path: Option<&str>,
+) -> Result<(String, ItemType, Vec<Symbol>), HrefError> {
+    let tcx = cx.tcx();
+    let def_kind = tcx.def_kind(did);
+    let did = match def_kind {
+        DefKind::AssocTy | DefKind::AssocFn | DefKind::AssocConst | DefKind::Variant => {
+            // documented on their parent's page
+            tcx.parent(did)
+        }
+        _ => did,
+    };
+    let cache = cx.cache();
+    let relative_to = &cx.current;
+    fn to_module_fqp(shortty: ItemType, fqp: &[Symbol]) -> &[Symbol] {
+        if shortty == ItemType::Module { fqp } else { &fqp[..fqp.len() - 1] }
+    }
+
+    if !did.is_local()
+        && !cache.access_levels.is_public(did)
+        && !cache.document_private
+        && !cache.primitive_locations.values().any(|&id| id == did)
+    {
+        return Err(HrefError::Private);
+    }
+
+    let mut is_remote = false;
+    let (fqp, shortty, mut url_parts) = match cache.paths.get(&did) {
+        Some(&(ref fqp, shortty)) => (fqp, shortty, {
+            let module_fqp = to_module_fqp(shortty, fqp.as_slice());
+            debug!(?fqp, ?shortty, ?module_fqp);
+            href_relative_parts(module_fqp, relative_to).collect()
+        }),
+        None => {
+            if let Some(&(ref fqp, shortty)) = cache.external_paths.get(&did) {
+                let module_fqp = to_module_fqp(shortty, fqp);
+                (
+                    fqp,
+                    shortty,
+                    match cache.extern_locations[&did.krate] {
+                        ExternalLocation::Remote(ref s) => {
+                            is_remote = true;
+                            let s = s.trim_end_matches('/');
+                            let mut builder = UrlPartsBuilder::singleton(s);
+                            builder.extend(module_fqp.iter().copied());
+                            builder
+                        }
+                        ExternalLocation::Local => {
+                            href_relative_parts(module_fqp, relative_to).collect()
+                        }
+                        ExternalLocation::Unknown => return Err(HrefError::DocumentationNotBuilt),
+                    },
+                )
+            } else if matches!(def_kind, DefKind::Macro(_)) {
+                return generate_macro_def_id_path(did, cx, root_path);
+            } else {
+                return Err(HrefError::NotInExternalCache);
+            }
+        }
+    };
+    if !is_remote {
+        if let Some(root_path) = root_path {
+            let root = root_path.trim_end_matches('/');
+            url_parts.push_front(root);
+        }
+    }
+    debug!(?url_parts);
+    match shortty {
+        ItemType::Module => {
+            url_parts.push("index.html");
+        }
+        _ => {
+            let prefix = shortty.as_str();
+            let last = fqp.last().unwrap();
+            url_parts.push_fmt(format_args!("{}.{}.html", prefix, last));
+        }
+    }
+    Ok((url_parts.finish(), shortty, fqp.to_vec()))
+}
+
+pub(crate) fn href(
+    did: DefId,
+    cx: &Context<'_>,
+) -> Result<(String, ItemType, Vec<Symbol>), HrefError> {
+    href_with_root_path(did, cx, None)
+}
+
+/// Both paths should only be modules.
+/// This is because modules get their own directories; that is, `std::vec` and `std::vec::Vec` will
+/// both need `../iter/trait.Iterator.html` to get at the iterator trait.
+pub(crate) fn href_relative_parts<'fqp>(
+    fqp: &'fqp [Symbol],
+    relative_to_fqp: &[Symbol],
+) -> Box<dyn Iterator<Item = Symbol> + 'fqp> {
+    for (i, (f, r)) in fqp.iter().zip(relative_to_fqp.iter()).enumerate() {
+        // e.g. linking to std::iter from std::vec (`dissimilar_part_count` will be 1)
+        if f != r {
+            let dissimilar_part_count = relative_to_fqp.len() - i;
+            let fqp_module = &fqp[i..fqp.len()];
+            return Box::new(
+                iter::repeat(sym::dotdot)
+                    .take(dissimilar_part_count)
+                    .chain(fqp_module.iter().copied()),
+            );
+        }
+    }
+    // e.g. linking to std::sync::atomic from std::sync
+    if relative_to_fqp.len() < fqp.len() {
+        Box::new(fqp[relative_to_fqp.len()..fqp.len()].iter().copied())
+    // e.g. linking to std::sync from std::sync::atomic
+    } else if fqp.len() < relative_to_fqp.len() {
+        let dissimilar_part_count = relative_to_fqp.len() - fqp.len();
+        Box::new(iter::repeat(sym::dotdot).take(dissimilar_part_count))
+    // linking to the same module
+    } else {
+        Box::new(iter::empty())
+    }
+}
+
+/// Used to render a [`clean::Path`].
+fn resolved_path<'cx>(
+    w: &mut fmt::Formatter<'_>,
+    did: DefId,
+    path: &clean::Path,
+    print_all: bool,
+    use_absolute: bool,
+    cx: &'cx Context<'_>,
+) -> fmt::Result {
+    let last = path.segments.last().unwrap();
+
+    if print_all {
+        for seg in &path.segments[..path.segments.len() - 1] {
+            write!(w, "{}::", if seg.name == kw::PathRoot { "" } else { seg.name.as_str() })?;
+        }
+    }
+    if w.alternate() {
+        write!(w, "{}{:#}", &last.name, last.args.print(cx))?;
+    } else {
+        let path = if use_absolute {
+            if let Ok((_, _, fqp)) = href(did, cx) {
+                format!(
+                    "{}::{}",
+                    join_with_double_colon(&fqp[..fqp.len() - 1]),
+                    anchor(did, *fqp.last().unwrap(), cx)
+                )
+            } else {
+                last.name.to_string()
+            }
+        } else {
+            anchor(did, last.name, cx).to_string()
+        };
+        write!(w, "{}{}", path, last.args.print(cx))?;
+    }
+    Ok(())
+}
+
+fn primitive_link(
+    f: &mut fmt::Formatter<'_>,
+    prim: clean::PrimitiveType,
+    name: &str,
+    cx: &Context<'_>,
+) -> fmt::Result {
+    primitive_link_fragment(f, prim, name, "", cx)
+}
+
+fn primitive_link_fragment(
+    f: &mut fmt::Formatter<'_>,
+    prim: clean::PrimitiveType,
+    name: &str,
+    fragment: &str,
+    cx: &Context<'_>,
+) -> fmt::Result {
+    let m = &cx.cache();
+    let mut needs_termination = false;
+    if !f.alternate() {
+        match m.primitive_locations.get(&prim) {
+            Some(&def_id) if def_id.is_local() => {
+                let len = cx.current.len();
+                let len = if len == 0 { 0 } else { len - 1 };
+                write!(
+                    f,
+                    "<a class=\"primitive\" href=\"{}primitive.{}.html{fragment}\">",
+                    "../".repeat(len),
+                    prim.as_sym()
+                )?;
+                needs_termination = true;
+            }
+            Some(&def_id) => {
+                let loc = match m.extern_locations[&def_id.krate] {
+                    ExternalLocation::Remote(ref s) => {
+                        let cname_sym = ExternalCrate { crate_num: def_id.krate }.name(cx.tcx());
+                        let builder: UrlPartsBuilder =
+                            [s.as_str().trim_end_matches('/'), cname_sym.as_str()]
+                                .into_iter()
+                                .collect();
+                        Some(builder)
+                    }
+                    ExternalLocation::Local => {
+                        let cname_sym = ExternalCrate { crate_num: def_id.krate }.name(cx.tcx());
+                        Some(if cx.current.first() == Some(&cname_sym) {
+                            iter::repeat(sym::dotdot).take(cx.current.len() - 1).collect()
+                        } else {
+                            iter::repeat(sym::dotdot)
+                                .take(cx.current.len())
+                                .chain(iter::once(cname_sym))
+                                .collect()
+                        })
+                    }
+                    ExternalLocation::Unknown => None,
+                };
+                if let Some(mut loc) = loc {
+                    loc.push_fmt(format_args!("primitive.{}.html", prim.as_sym()));
+                    write!(f, "<a class=\"primitive\" href=\"{}{fragment}\">", loc.finish())?;
+                    needs_termination = true;
+                }
+            }
+            None => {}
+        }
+    }
+    write!(f, "{}", name)?;
+    if needs_termination {
+        write!(f, "</a>")?;
+    }
+    Ok(())
+}
+
+/// Helper to render type parameters
+fn tybounds<'a, 'tcx: 'a>(
+    bounds: &'a [clean::PolyTrait],
+    lt: &'a Option<clean::Lifetime>,
+    cx: &'a Context<'tcx>,
+) -> impl fmt::Display + 'a + Captures<'tcx> {
+    display_fn(move |f| {
+        for (i, bound) in bounds.iter().enumerate() {
+            if i > 0 {
+                write!(f, " + ")?;
+            }
+
+            fmt::Display::fmt(&bound.print(cx), f)?;
+        }
+
+        if let Some(lt) = lt {
+            write!(f, " + ")?;
+            fmt::Display::fmt(&lt.print(), f)?;
+        }
+        Ok(())
+    })
+}
+
+pub(crate) fn anchor<'a, 'cx: 'a>(
+    did: DefId,
+    text: Symbol,
+    cx: &'cx Context<'_>,
+) -> impl fmt::Display + 'a {
+    let parts = href(did, cx);
+    display_fn(move |f| {
+        if let Ok((url, short_ty, fqp)) = parts {
+            write!(
+                f,
+                r#"<a class="{}" href="{}" title="{} {}">{}</a>"#,
+                short_ty,
+                url,
+                short_ty,
+                join_with_double_colon(&fqp),
+                text.as_str()
+            )
+        } else {
+            write!(f, "{}", text)
+        }
+    })
+}
+
+fn fmt_type<'cx>(
+    t: &clean::Type,
+    f: &mut fmt::Formatter<'_>,
+    use_absolute: bool,
+    cx: &'cx Context<'_>,
+) -> fmt::Result {
+    trace!("fmt_type(t = {:?})", t);
+
+    match *t {
+        clean::Generic(name) => write!(f, "{}", name),
+        clean::Type::Path { ref path } => {
+            // Paths like `T::Output` and `Self::Output` should be rendered with all segments.
+            let did = path.def_id();
+            resolved_path(f, did, path, path.is_assoc_ty(), use_absolute, cx)
+        }
+        clean::DynTrait(ref bounds, ref lt) => {
+            f.write_str("dyn ")?;
+            fmt::Display::fmt(&tybounds(bounds, lt, cx), f)
+        }
+        clean::Infer => write!(f, "_"),
+        clean::Primitive(clean::PrimitiveType::Never) => {
+            primitive_link(f, PrimitiveType::Never, "!", cx)
+        }
+        clean::Primitive(prim) => primitive_link(f, prim, prim.as_sym().as_str(), cx),
+        clean::BareFunction(ref decl) => {
+            if f.alternate() {
+                write!(
+                    f,
+                    "{:#}{}{:#}fn{:#}",
+                    decl.print_hrtb_with_space(cx),
+                    decl.unsafety.print_with_space(),
+                    print_abi_with_space(decl.abi),
+                    decl.decl.print(cx),
+                )
+            } else {
+                write!(
+                    f,
+                    "{}{}{}",
+                    decl.print_hrtb_with_space(cx),
+                    decl.unsafety.print_with_space(),
+                    print_abi_with_space(decl.abi)
+                )?;
+                primitive_link(f, PrimitiveType::Fn, "fn", cx)?;
+                write!(f, "{}", decl.decl.print(cx))
+            }
+        }
+        clean::Tuple(ref typs) => {
+            match &typs[..] {
+                &[] => primitive_link(f, PrimitiveType::Unit, "()", cx),
+                &[ref one] => {
+                    if let clean::Generic(name) = one {
+                        primitive_link(f, PrimitiveType::Tuple, &format!("({name},)"), cx)
+                    } else {
+                        write!(f, "(")?;
+                        // Carry `f.alternate()` into this display w/o branching manually.
+                        fmt::Display::fmt(&one.print(cx), f)?;
+                        write!(f, ",)")
+                    }
+                }
+                many => {
+                    let generic_names: Vec<Symbol> = many
+                        .iter()
+                        .filter_map(|t| match t {
+                            clean::Generic(name) => Some(*name),
+                            _ => None,
+                        })
+                        .collect();
+                    let is_generic = generic_names.len() == many.len();
+                    if is_generic {
+                        primitive_link(
+                            f,
+                            PrimitiveType::Tuple,
+                            &format!("({})", generic_names.iter().map(|s| s.as_str()).join(", ")),
+                            cx,
+                        )
+                    } else {
+                        write!(f, "(")?;
+                        for (i, item) in many.iter().enumerate() {
+                            if i != 0 {
+                                write!(f, ", ")?;
+                            }
+                            // Carry `f.alternate()` into this display w/o branching manually.
+                            fmt::Display::fmt(&item.print(cx), f)?;
+                        }
+                        write!(f, ")")
+                    }
+                }
+            }
+        }
+        clean::Slice(ref t) => match **t {
+            clean::Generic(name) => {
+                primitive_link(f, PrimitiveType::Slice, &format!("[{name}]"), cx)
+            }
+            _ => {
+                write!(f, "[")?;
+                fmt::Display::fmt(&t.print(cx), f)?;
+                write!(f, "]")
+            }
+        },
+        clean::Array(ref t, ref n) => {
+            primitive_link(f, PrimitiveType::Array, "[", cx)?;
+            fmt::Display::fmt(&t.print(cx), f)?;
+            if f.alternate() {
+                primitive_link(f, PrimitiveType::Array, &format!("; {}]", n), cx)
+            } else {
+                primitive_link(f, PrimitiveType::Array, &format!("; {}]", Escape(n)), cx)
+            }
+        }
+        clean::RawPointer(m, ref t) => {
+            let m = match m {
+                hir::Mutability::Mut => "mut",
+                hir::Mutability::Not => "const",
+            };
+
+            if matches!(**t, clean::Generic(_)) || t.is_assoc_ty() {
+                let text = if f.alternate() {
+                    format!("*{} {:#}", m, t.print(cx))
+                } else {
+                    format!("*{} {}", m, t.print(cx))
+                };
+                primitive_link(f, clean::PrimitiveType::RawPointer, &text, cx)
+            } else {
+                primitive_link(f, clean::PrimitiveType::RawPointer, &format!("*{} ", m), cx)?;
+                fmt::Display::fmt(&t.print(cx), f)
+            }
+        }
+        clean::BorrowedRef { lifetime: ref l, mutability, type_: ref ty } => {
+            let lt = match l {
+                Some(l) => format!("{} ", l.print()),
+                _ => String::new(),
+            };
+            let m = mutability.print_with_space();
+            let amp = if f.alternate() { "&".to_string() } else { "&amp;".to_string() };
+            match **ty {
+                clean::DynTrait(ref bounds, ref trait_lt)
+                    if bounds.len() > 1 || trait_lt.is_some() =>
+                {
+                    write!(f, "{}{}{}(", amp, lt, m)?;
+                    fmt_type(ty, f, use_absolute, cx)?;
+                    write!(f, ")")
+                }
+                clean::Generic(..) => {
+                    primitive_link(
+                        f,
+                        PrimitiveType::Reference,
+                        &format!("{}{}{}", amp, lt, m),
+                        cx,
+                    )?;
+                    fmt_type(ty, f, use_absolute, cx)
+                }
+                _ => {
+                    write!(f, "{}{}{}", amp, lt, m)?;
+                    fmt_type(ty, f, use_absolute, cx)
+                }
+            }
+        }
+        clean::ImplTrait(ref bounds) => {
+            if f.alternate() {
+                write!(f, "impl {:#}", print_generic_bounds(bounds, cx))
+            } else {
+                write!(f, "impl {}", print_generic_bounds(bounds, cx))
+            }
+        }
+        clean::QPath { ref assoc, ref self_type, ref trait_, should_show_cast } => {
+            if f.alternate() {
+                if should_show_cast {
+                    write!(f, "<{:#} as {:#}>::", self_type.print(cx), trait_.print(cx))?
+                } else {
+                    write!(f, "{:#}::", self_type.print(cx))?
+                }
+            } else {
+                if should_show_cast {
+                    write!(f, "&lt;{} as {}&gt;::", self_type.print(cx), trait_.print(cx))?
+                } else {
+                    write!(f, "{}::", self_type.print(cx))?
+                }
+            };
+            // It's pretty unsightly to look at `<A as B>::C` in output, and
+            // we've got hyperlinking on our side, so try to avoid longer
+            // notation as much as possible by making `C` a hyperlink to trait
+            // `B` to disambiguate.
+            //
+            // FIXME: this is still a lossy conversion and there should probably
+            //        be a better way of representing this in general? Most of
+            //        the ugliness comes from inlining across crates where
+            //        everything comes in as a fully resolved QPath (hard to
+            //        look at).
+            match href(trait_.def_id(), cx) {
+                Ok((ref url, _, ref path)) if !f.alternate() => {
+                    write!(
+                        f,
+                        "<a class=\"associatedtype\" href=\"{url}#{shortty}.{name}\" \
+                                    title=\"type {path}::{name}\">{name}</a>{args}",
+                        url = url,
+                        shortty = ItemType::AssocType,
+                        name = assoc.name,
+                        path = join_with_double_colon(path),
+                        args = assoc.args.print(cx),
+                    )?;
+                }
+                _ => write!(f, "{}{:#}", assoc.name, assoc.args.print(cx))?,
+            }
+            Ok(())
+        }
+    }
+}
+
+impl clean::Type {
+    pub(crate) fn print<'b, 'a: 'b, 'tcx: 'a>(
+        &'a self,
+        cx: &'a Context<'tcx>,
+    ) -> impl fmt::Display + 'b + Captures<'tcx> {
+        display_fn(move |f| fmt_type(self, f, false, cx))
+    }
+}
+
+impl clean::Path {
+    pub(crate) fn print<'b, 'a: 'b, 'tcx: 'a>(
+        &'a self,
+        cx: &'a Context<'tcx>,
+    ) -> impl fmt::Display + 'b + Captures<'tcx> {
+        display_fn(move |f| resolved_path(f, self.def_id(), self, false, false, cx))
+    }
+}
+
+impl clean::Impl {
+    pub(crate) fn print<'a, 'tcx: 'a>(
+        &'a self,
+        use_absolute: bool,
+        cx: &'a Context<'tcx>,
+    ) -> impl fmt::Display + 'a + Captures<'tcx> {
+        display_fn(move |f| {
+            if f.alternate() {
+                write!(f, "impl{:#} ", self.generics.print(cx))?;
+            } else {
+                write!(f, "impl{} ", self.generics.print(cx))?;
+            }
+
+            if let Some(ref ty) = self.trait_ {
+                match self.polarity {
+                    ty::ImplPolarity::Positive | ty::ImplPolarity::Reservation => {}
+                    ty::ImplPolarity::Negative => write!(f, "!")?,
+                }
+                fmt::Display::fmt(&ty.print(cx), f)?;
+                write!(f, " for ")?;
+            }
+
+            if let clean::Type::Tuple(types) = &self.for_ &&
+                let [clean::Type::Generic(name)] = &types[..] &&
+                (self.kind.is_fake_variadic() || self.kind.is_auto())
+            {
+                // Hardcoded anchor library/core/src/primitive_docs.rs
+                // Link should match `# Trait implementations`
+                primitive_link_fragment(f, PrimitiveType::Tuple, &format!("({name}₁, {name}₂, …, {name}ₙ)"), "#trait-implementations-1", cx)?;
+            } else if let clean::BareFunction(bare_fn) = &self.for_ &&
+                let [clean::Argument { type_: clean::Type::Generic(name), .. }] = &bare_fn.decl.inputs.values[..] &&
+                (self.kind.is_fake_variadic() || self.kind.is_auto())
+            {
+                // Hardcoded anchor library/core/src/primitive_docs.rs
+                // Link should match `# Trait implementations`
+
+                let hrtb = bare_fn.print_hrtb_with_space(cx);
+                let unsafety = bare_fn.unsafety.print_with_space();
+                let abi = print_abi_with_space(bare_fn.abi);
+                if f.alternate() {
+                    write!(
+                        f,
+                        "{hrtb:#}{unsafety}{abi:#}",
+                    )?;
+                } else {
+                    write!(
+                        f,
+                        "{hrtb}{unsafety}{abi}",
+                    )?;
+                }
+                let ellipsis = if bare_fn.decl.c_variadic {
+                    ", ..."
+                } else {
+                    ""
+                };
+                primitive_link_fragment(f, PrimitiveType::Tuple, &format!("fn ({name}₁, {name}₂, …, {name}ₙ{ellipsis})"), "#trait-implementations-1", cx)?;
+                // Write output.
+                if let clean::FnRetTy::Return(ty) = &bare_fn.decl.output {
+                    write!(f, " -> ")?;
+                    fmt_type(ty, f, use_absolute, cx)?;
+                }
+            } else if let Some(ty) = self.kind.as_blanket_ty() {
+                fmt_type(ty, f, use_absolute, cx)?;
+            } else {
+                fmt_type(&self.for_, f, use_absolute, cx)?;
+            }
+
+            fmt::Display::fmt(&print_where_clause(&self.generics, cx, 0, Ending::Newline), f)?;
+            Ok(())
+        })
+    }
+}
+
+impl clean::Arguments {
+    pub(crate) fn print<'a, 'tcx: 'a>(
+        &'a self,
+        cx: &'a Context<'tcx>,
+    ) -> impl fmt::Display + 'a + Captures<'tcx> {
+        display_fn(move |f| {
+            for (i, input) in self.values.iter().enumerate() {
+                if !input.name.is_empty() {
+                    write!(f, "{}: ", input.name)?;
+                }
+                if f.alternate() {
+                    write!(f, "{:#}", input.type_.print(cx))?;
+                } else {
+                    write!(f, "{}", input.type_.print(cx))?;
+                }
+                if i + 1 < self.values.len() {
+                    write!(f, ", ")?;
+                }
+            }
+            Ok(())
+        })
+    }
+}
+
+impl clean::FnRetTy {
+    pub(crate) fn print<'a, 'tcx: 'a>(
+        &'a self,
+        cx: &'a Context<'tcx>,
+    ) -> impl fmt::Display + 'a + Captures<'tcx> {
+        display_fn(move |f| match self {
+            clean::Return(clean::Tuple(tys)) if tys.is_empty() => Ok(()),
+            clean::Return(ty) if f.alternate() => {
+                write!(f, " -> {:#}", ty.print(cx))
+            }
+            clean::Return(ty) => write!(f, " -&gt; {}", ty.print(cx)),
+            clean::DefaultReturn => Ok(()),
+        })
+    }
+}
+
+impl clean::BareFunctionDecl {
+    fn print_hrtb_with_space<'a, 'tcx: 'a>(
+        &'a self,
+        cx: &'a Context<'tcx>,
+    ) -> impl fmt::Display + 'a + Captures<'tcx> {
+        display_fn(move |f| {
+            if !self.generic_params.is_empty() {
+                write!(
+                    f,
+                    "for&lt;{}&gt; ",
+                    comma_sep(self.generic_params.iter().map(|g| g.print(cx)), true)
+                )
+            } else {
+                Ok(())
+            }
+        })
+    }
+}
+
+impl clean::FnDecl {
+    pub(crate) fn print<'b, 'a: 'b, 'tcx: 'a>(
+        &'a self,
+        cx: &'a Context<'tcx>,
+    ) -> impl fmt::Display + 'b + Captures<'tcx> {
+        display_fn(move |f| {
+            let ellipsis = if self.c_variadic { ", ..." } else { "" };
+            if f.alternate() {
+                write!(
+                    f,
+                    "({args:#}{ellipsis}){arrow:#}",
+                    args = self.inputs.print(cx),
+                    ellipsis = ellipsis,
+                    arrow = self.output.print(cx)
+                )
+            } else {
+                write!(
+                    f,
+                    "({args}{ellipsis}){arrow}",
+                    args = self.inputs.print(cx),
+                    ellipsis = ellipsis,
+                    arrow = self.output.print(cx)
+                )
+            }
+        })
+    }
+
+    /// * `header_len`: The length of the function header and name. In other words, the number of
+    ///   characters in the function declaration up to but not including the parentheses.
+    ///   <br>Used to determine line-wrapping.
+    /// * `indent`: The number of spaces to indent each successive line with, if line-wrapping is
+    ///   necessary.
+    /// * `asyncness`: Whether the function is async or not.
+    pub(crate) fn full_print<'a, 'tcx: 'a>(
+        &'a self,
+        header_len: usize,
+        indent: usize,
+        asyncness: hir::IsAsync,
+        cx: &'a Context<'tcx>,
+    ) -> impl fmt::Display + 'a + Captures<'tcx> {
+        display_fn(move |f| self.inner_full_print(header_len, indent, asyncness, f, cx))
+    }
+
+    fn inner_full_print(
+        &self,
+        header_len: usize,
+        indent: usize,
+        asyncness: hir::IsAsync,
+        f: &mut fmt::Formatter<'_>,
+        cx: &Context<'_>,
+    ) -> fmt::Result {
+        let amp = if f.alternate() { "&" } else { "&amp;" };
+        let mut args = Buffer::html();
+        let mut args_plain = Buffer::new();
+        for (i, input) in self.inputs.values.iter().enumerate() {
+            if let Some(selfty) = input.to_self() {
+                match selfty {
+                    clean::SelfValue => {
+                        args.push_str("self");
+                        args_plain.push_str("self");
+                    }
+                    clean::SelfBorrowed(Some(ref lt), mtbl) => {
+                        write!(args, "{}{} {}self", amp, lt.print(), mtbl.print_with_space());
+                        write!(args_plain, "&{} {}self", lt.print(), mtbl.print_with_space());
+                    }
+                    clean::SelfBorrowed(None, mtbl) => {
+                        write!(args, "{}{}self", amp, mtbl.print_with_space());
+                        write!(args_plain, "&{}self", mtbl.print_with_space());
+                    }
+                    clean::SelfExplicit(ref typ) => {
+                        if f.alternate() {
+                            write!(args, "self: {:#}", typ.print(cx));
+                        } else {
+                            write!(args, "self: {}", typ.print(cx));
+                        }
+                        write!(args_plain, "self: {:#}", typ.print(cx));
+                    }
+                }
+            } else {
+                if i > 0 {
+                    args.push_str("<br>");
+                }
+                if input.is_const {
+                    args.push_str("const ");
+                    args_plain.push_str("const ");
+                }
+                if !input.name.is_empty() {
+                    write!(args, "{}: ", input.name);
+                    write!(args_plain, "{}: ", input.name);
+                }
+
+                if f.alternate() {
+                    write!(args, "{:#}", input.type_.print(cx));
+                } else {
+                    write!(args, "{}", input.type_.print(cx));
+                }
+                write!(args_plain, "{:#}", input.type_.print(cx));
+            }
+            if i + 1 < self.inputs.values.len() {
+                args.push_str(",");
+                args_plain.push_str(",");
+            }
+        }
+
+        let mut args_plain = format!("({})", args_plain.into_inner());
+        let mut args = args.into_inner();
+
+        if self.c_variadic {
+            args.push_str(",<br> ...");
+            args_plain.push_str(", ...");
+        }
+
+        let arrow_plain;
+        let arrow = if let hir::IsAsync::Async = asyncness {
+            let output = self.sugared_async_return_type();
+            arrow_plain = format!("{:#}", output.print(cx));
+            if f.alternate() { arrow_plain.clone() } else { format!("{}", output.print(cx)) }
+        } else {
+            arrow_plain = format!("{:#}", self.output.print(cx));
+            if f.alternate() { arrow_plain.clone() } else { format!("{}", self.output.print(cx)) }
+        };
+
+        let declaration_len = header_len + args_plain.len() + arrow_plain.len();
+        let output = if declaration_len > 80 {
+            let full_pad = format!("<br>{}", "&nbsp;".repeat(indent + 4));
+            let close_pad = format!("<br>{}", "&nbsp;".repeat(indent));
+            format!(
+                "({pad}{args}{close}){arrow}",
+                pad = if self.inputs.values.is_empty() { "" } else { &full_pad },
+                args = args.replace("<br>", &full_pad),
+                close = close_pad,
+                arrow = arrow
+            )
+        } else {
+            format!("({args}){arrow}", args = args.replace("<br>", " "), arrow = arrow)
+        };
+
+        if f.alternate() {
+            write!(f, "{}", output.replace("<br>", "\n"))
+        } else {
+            write!(f, "{}", output)
+        }
+    }
+}
+
+impl clean::Visibility {
+    pub(crate) fn print_with_space<'a, 'tcx: 'a>(
+        self,
+        item_did: ItemId,
+        cx: &'a Context<'tcx>,
+    ) -> impl fmt::Display + 'a + Captures<'tcx> {
+        use std::fmt::Write as _;
+
+        let to_print: Cow<'static, str> = match self {
+            clean::Public => "pub ".into(),
+            clean::Inherited => "".into(),
+            clean::Visibility::Restricted(vis_did) => {
+                // FIXME(camelid): This may not work correctly if `item_did` is a module.
+                //                 However, rustdoc currently never displays a module's
+                //                 visibility, so it shouldn't matter.
+                let parent_module = find_nearest_parent_module(cx.tcx(), item_did.expect_def_id());
+
+                if vis_did.is_crate_root() {
+                    "pub(crate) ".into()
+                } else if parent_module == Some(vis_did) {
+                    // `pub(in foo)` where `foo` is the parent module
+                    // is the same as no visibility modifier
+                    "".into()
+                } else if parent_module
+                    .and_then(|parent| find_nearest_parent_module(cx.tcx(), parent))
+                    == Some(vis_did)
+                {
+                    "pub(super) ".into()
+                } else {
+                    let path = cx.tcx().def_path(vis_did);
+                    debug!("path={:?}", path);
+                    // modified from `resolved_path()` to work with `DefPathData`
+                    let last_name = path.data.last().unwrap().data.get_opt_name().unwrap();
+                    let anchor = anchor(vis_did, last_name, cx).to_string();
+
+                    let mut s = "pub(in ".to_owned();
+                    for seg in &path.data[..path.data.len() - 1] {
+                        let _ = write!(s, "{}::", seg.data.get_opt_name().unwrap());
+                    }
+                    let _ = write!(s, "{}) ", anchor);
+                    s.into()
+                }
+            }
+        };
+        display_fn(move |f| write!(f, "{}", to_print))
+    }
+
+    /// This function is the same as print_with_space, except that it renders no links.
+    /// It's used for macros' rendered source view, which is syntax highlighted and cannot have
+    /// any HTML in it.
+    pub(crate) fn to_src_with_space<'a, 'tcx: 'a>(
+        self,
+        tcx: TyCtxt<'tcx>,
+        item_did: DefId,
+    ) -> impl fmt::Display + 'a + Captures<'tcx> {
+        let to_print = match self {
+            clean::Public => "pub ".to_owned(),
+            clean::Inherited => String::new(),
+            clean::Visibility::Restricted(vis_did) => {
+                // FIXME(camelid): This may not work correctly if `item_did` is a module.
+                //                 However, rustdoc currently never displays a module's
+                //                 visibility, so it shouldn't matter.
+                let parent_module = find_nearest_parent_module(tcx, item_did);
+
+                if vis_did.is_crate_root() {
+                    "pub(crate) ".to_owned()
+                } else if parent_module == Some(vis_did) {
+                    // `pub(in foo)` where `foo` is the parent module
+                    // is the same as no visibility modifier
+                    String::new()
+                } else if parent_module.and_then(|parent| find_nearest_parent_module(tcx, parent))
+                    == Some(vis_did)
+                {
+                    "pub(super) ".to_owned()
+                } else {
+                    format!("pub(in {}) ", tcx.def_path_str(vis_did))
+                }
+            }
+        };
+        display_fn(move |f| f.write_str(&to_print))
+    }
+}
+
+pub(crate) trait PrintWithSpace {
+    fn print_with_space(&self) -> &str;
+}
+
+impl PrintWithSpace for hir::Unsafety {
+    fn print_with_space(&self) -> &str {
+        match self {
+            hir::Unsafety::Unsafe => "unsafe ",
+            hir::Unsafety::Normal => "",
+        }
+    }
+}
+
+impl PrintWithSpace for hir::IsAsync {
+    fn print_with_space(&self) -> &str {
+        match self {
+            hir::IsAsync::Async => "async ",
+            hir::IsAsync::NotAsync => "",
+        }
+    }
+}
+
+impl PrintWithSpace for hir::Mutability {
+    fn print_with_space(&self) -> &str {
+        match self {
+            hir::Mutability::Not => "",
+            hir::Mutability::Mut => "mut ",
+        }
+    }
+}
+
+pub(crate) fn print_constness_with_space(
+    c: &hir::Constness,
+    s: Option<ConstStability>,
+) -> &'static str {
+    match (c, s) {
+        // const stable or when feature(staged_api) is not set
+        (
+            hir::Constness::Const,
+            Some(ConstStability { level: StabilityLevel::Stable { .. }, .. }),
+        )
+        | (hir::Constness::Const, None) => "const ",
+        // const unstable or not const
+        _ => "",
+    }
+}
+
+impl clean::Import {
+    pub(crate) fn print<'a, 'tcx: 'a>(
+        &'a self,
+        cx: &'a Context<'tcx>,
+    ) -> impl fmt::Display + 'a + Captures<'tcx> {
+        display_fn(move |f| match self.kind {
+            clean::ImportKind::Simple(name) => {
+                if name == self.source.path.last() {
+                    write!(f, "use {};", self.source.print(cx))
+                } else {
+                    write!(f, "use {} as {};", self.source.print(cx), name)
+                }
+            }
+            clean::ImportKind::Glob => {
+                if self.source.path.segments.is_empty() {
+                    write!(f, "use *;")
+                } else {
+                    write!(f, "use {}::*;", self.source.print(cx))
+                }
+            }
+        })
+    }
+}
+
+impl clean::ImportSource {
+    pub(crate) fn print<'a, 'tcx: 'a>(
+        &'a self,
+        cx: &'a Context<'tcx>,
+    ) -> impl fmt::Display + 'a + Captures<'tcx> {
+        display_fn(move |f| match self.did {
+            Some(did) => resolved_path(f, did, &self.path, true, false, cx),
+            _ => {
+                for seg in &self.path.segments[..self.path.segments.len() - 1] {
+                    write!(f, "{}::", seg.name)?;
+                }
+                let name = self.path.last();
+                if let hir::def::Res::PrimTy(p) = self.path.res {
+                    primitive_link(f, PrimitiveType::from(p), name.as_str(), cx)?;
+                } else {
+                    write!(f, "{}", name)?;
+                }
+                Ok(())
+            }
+        })
+    }
+}
+
+impl clean::TypeBinding {
+    pub(crate) fn print<'a, 'tcx: 'a>(
+        &'a self,
+        cx: &'a Context<'tcx>,
+    ) -> impl fmt::Display + 'a + Captures<'tcx> {
+        display_fn(move |f| {
+            f.write_str(self.assoc.name.as_str())?;
+            if f.alternate() {
+                write!(f, "{:#}", self.assoc.args.print(cx))?;
+            } else {
+                write!(f, "{}", self.assoc.args.print(cx))?;
+            }
+            match self.kind {
+                clean::TypeBindingKind::Equality { ref term } => {
+                    if f.alternate() {
+                        write!(f, " = {:#}", term.print(cx))?;
+                    } else {
+                        write!(f, " = {}", term.print(cx))?;
+                    }
+                }
+                clean::TypeBindingKind::Constraint { ref bounds } => {
+                    if !bounds.is_empty() {
+                        if f.alternate() {
+                            write!(f, ": {:#}", print_generic_bounds(bounds, cx))?;
+                        } else {
+                            write!(f, ":&nbsp;{}", print_generic_bounds(bounds, cx))?;
+                        }
+                    }
+                }
+            }
+            Ok(())
+        })
+    }
+}
+
+pub(crate) fn print_abi_with_space(abi: Abi) -> impl fmt::Display {
+    display_fn(move |f| {
+        let quot = if f.alternate() { "\"" } else { "&quot;" };
+        match abi {
+            Abi::Rust => Ok(()),
+            abi => write!(f, "extern {0}{1}{0} ", quot, abi.name()),
+        }
+    })
+}
+
+pub(crate) fn print_default_space<'a>(v: bool) -> &'a str {
+    if v { "default " } else { "" }
+}
+
+impl clean::GenericArg {
+    pub(crate) fn print<'a, 'tcx: 'a>(
+        &'a self,
+        cx: &'a Context<'tcx>,
+    ) -> impl fmt::Display + 'a + Captures<'tcx> {
+        display_fn(move |f| match self {
+            clean::GenericArg::Lifetime(lt) => fmt::Display::fmt(&lt.print(), f),
+            clean::GenericArg::Type(ty) => fmt::Display::fmt(&ty.print(cx), f),
+            clean::GenericArg::Const(ct) => fmt::Display::fmt(&ct.print(cx.tcx()), f),
+            clean::GenericArg::Infer => fmt::Display::fmt("_", f),
+        })
+    }
+}
+
+impl clean::types::Term {
+    pub(crate) fn print<'a, 'tcx: 'a>(
+        &'a self,
+        cx: &'a Context<'tcx>,
+    ) -> impl fmt::Display + 'a + Captures<'tcx> {
+        match self {
+            clean::types::Term::Type(ty) => ty.print(cx),
+            _ => todo!(),
+        }
+    }
+}
+
+pub(crate) fn display_fn(
+    f: impl FnOnce(&mut fmt::Formatter<'_>) -> fmt::Result,
+) -> impl fmt::Display {
+    struct WithFormatter<F>(Cell<Option<F>>);
+
+    impl<F> fmt::Display for WithFormatter<F>
+    where
+        F: FnOnce(&mut fmt::Formatter<'_>) -> fmt::Result,
+    {
+        fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+            (self.0.take()).unwrap()(f)
+        }
+    }
+
+    WithFormatter(Cell::new(Some(f)))
+}
diff --git a/src/librustdoc/html/highlight.rs b/src/librustdoc/html/highlight.rs
new file mode 100644
index 000000000..05547ea15
--- /dev/null
+++ b/src/librustdoc/html/highlight.rs
@@ -0,0 +1,805 @@
+//! Basic syntax highlighting functionality.
+//!
+//! This module uses librustc_ast's lexer to provide token-based highlighting for
+//! the HTML documentation generated by rustdoc.
+//!
+//! Use the `render_with_highlighting` to highlight some rust code.
+
+use crate::clean::PrimitiveType;
+use crate::html::escape::Escape;
+use crate::html::render::Context;
+
+use std::collections::VecDeque;
+use std::fmt::{Display, Write};
+
+use rustc_data_structures::fx::FxHashMap;
+use rustc_lexer::{LiteralKind, TokenKind};
+use rustc_span::edition::Edition;
+use rustc_span::symbol::Symbol;
+use rustc_span::{BytePos, Span, DUMMY_SP};
+
+use super::format::{self, Buffer};
+use super::render::LinkFromSrc;
+
+/// This type is needed in case we want to render links on items to allow to go to their definition.
+pub(crate) struct HrefContext<'a, 'b, 'c> {
+    pub(crate) context: &'a Context<'b>,
+    /// This span contains the current file we're going through.
+    pub(crate) file_span: Span,
+    /// This field is used to know "how far" from the top of the directory we are to link to either
+    /// documentation pages or other source pages.
+    pub(crate) root_path: &'c str,
+}
+
+/// Decorations are represented as a map from CSS class to vector of character ranges.
+/// Each range will be wrapped in a span with that class.
+pub(crate) struct DecorationInfo(pub(crate) FxHashMap<&'static str, Vec<(u32, u32)>>);
+
+/// Highlights `src`, returning the HTML output.
+pub(crate) fn render_with_highlighting(
+    src: &str,
+    out: &mut Buffer,
+    class: Option<&str>,
+    playground_button: Option<&str>,
+    tooltip: Option<(Option<Edition>, &str)>,
+    edition: Edition,
+    extra_content: Option<Buffer>,
+    href_context: Option<HrefContext<'_, '_, '_>>,
+    decoration_info: Option<DecorationInfo>,
+) {
+    debug!("highlighting: ================\n{}\n==============", src);
+    if let Some((edition_info, class)) = tooltip {
+        write!(
+            out,
+            "<div class='information'><div class='tooltip {}'{}>ⓘ</div></div>",
+            class,
+            if let Some(edition_info) = edition_info {
+                format!(" data-edition=\"{}\"", edition_info)
+            } else {
+                String::new()
+            },
+        );
+    }
+
+    write_header(out, class, extra_content);
+    write_code(out, src, edition, href_context, decoration_info);
+    write_footer(out, playground_button);
+}
+
+fn write_header(out: &mut Buffer, class: Option<&str>, extra_content: Option<Buffer>) {
+    write!(out, "<div class=\"example-wrap\">");
+    if let Some(extra) = extra_content {
+        out.push_buffer(extra);
+    }
+    if let Some(class) = class {
+        write!(out, "<pre class=\"rust {}\">", class);
+    } else {
+        write!(out, "<pre class=\"rust\">");
+    }
+    write!(out, "<code>");
+}
+
+/// Convert the given `src` source code into HTML by adding classes for highlighting.
+///
+/// This code is used to render code blocks (in the documentation) as well as the source code pages.
+///
+/// Some explanations on the last arguments:
+///
+/// In case we are rendering a code block and not a source code file, `href_context` will be `None`.
+/// To put it more simply: if `href_context` is `None`, the code won't try to generate links to an
+/// item definition.
+///
+/// More explanations about spans and how we use them here are provided in the
+fn write_code(
+    out: &mut Buffer,
+    src: &str,
+    edition: Edition,
+    href_context: Option<HrefContext<'_, '_, '_>>,
+    decoration_info: Option<DecorationInfo>,
+) {
+    // This replace allows to fix how the code source with DOS backline characters is displayed.
+    let src = src.replace("\r\n", "\n");
+    let mut closing_tags: Vec<&'static str> = Vec::new();
+    Classifier::new(
+        &src,
+        edition,
+        href_context.as_ref().map(|c| c.file_span).unwrap_or(DUMMY_SP),
+        decoration_info,
+    )
+    .highlight(&mut |highlight| {
+        match highlight {
+            Highlight::Token { text, class } => string(out, Escape(text), class, &href_context),
+            Highlight::EnterSpan { class } => {
+                closing_tags.push(enter_span(out, class, &href_context))
+            }
+            Highlight::ExitSpan => {
+                exit_span(out, closing_tags.pop().expect("ExitSpan without EnterSpan"))
+            }
+        };
+    });
+}
+
+fn write_footer(out: &mut Buffer, playground_button: Option<&str>) {
+    writeln!(out, "</code></pre>{}</div>", playground_button.unwrap_or_default());
+}
+
+/// How a span of text is classified. Mostly corresponds to token kinds.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+enum Class {
+    Comment,
+    DocComment,
+    Attribute,
+    KeyWord,
+    // Keywords that do pointer/reference stuff.
+    RefKeyWord,
+    Self_(Span),
+    Op,
+    Macro(Span),
+    MacroNonTerminal,
+    String,
+    Number,
+    Bool,
+    Ident(Span),
+    Lifetime,
+    PreludeTy,
+    PreludeVal,
+    QuestionMark,
+    Decoration(&'static str),
+}
+
+impl Class {
+    /// Returns the css class expected by rustdoc for each `Class`.
+    fn as_html(self) -> &'static str {
+        match self {
+            Class::Comment => "comment",
+            Class::DocComment => "doccomment",
+            Class::Attribute => "attribute",
+            Class::KeyWord => "kw",
+            Class::RefKeyWord => "kw-2",
+            Class::Self_(_) => "self",
+            Class::Op => "op",
+            Class::Macro(_) => "macro",
+            Class::MacroNonTerminal => "macro-nonterminal",
+            Class::String => "string",
+            Class::Number => "number",
+            Class::Bool => "bool-val",
+            Class::Ident(_) => "ident",
+            Class::Lifetime => "lifetime",
+            Class::PreludeTy => "prelude-ty",
+            Class::PreludeVal => "prelude-val",
+            Class::QuestionMark => "question-mark",
+            Class::Decoration(kind) => kind,
+        }
+    }
+
+    /// In case this is an item which can be converted into a link to a definition, it'll contain
+    /// a "span" (a tuple representing `(lo, hi)` equivalent of `Span`).
+    fn get_span(self) -> Option<Span> {
+        match self {
+            Self::Ident(sp) | Self::Self_(sp) | Self::Macro(sp) => Some(sp),
+            Self::Comment
+            | Self::DocComment
+            | Self::Attribute
+            | Self::KeyWord
+            | Self::RefKeyWord
+            | Self::Op
+            | Self::MacroNonTerminal
+            | Self::String
+            | Self::Number
+            | Self::Bool
+            | Self::Lifetime
+            | Self::PreludeTy
+            | Self::PreludeVal
+            | Self::QuestionMark
+            | Self::Decoration(_) => None,
+        }
+    }
+}
+
+enum Highlight<'a> {
+    Token { text: &'a str, class: Option<Class> },
+    EnterSpan { class: Class },
+    ExitSpan,
+}
+
+struct TokenIter<'a> {
+    src: &'a str,
+}
+
+impl<'a> Iterator for TokenIter<'a> {
+    type Item = (TokenKind, &'a str);
+    fn next(&mut self) -> Option<(TokenKind, &'a str)> {
+        if self.src.is_empty() {
+            return None;
+        }
+        let token = rustc_lexer::first_token(self.src);
+        let (text, rest) = self.src.split_at(token.len as usize);
+        self.src = rest;
+        Some((token.kind, text))
+    }
+}
+
+/// Classifies into identifier class; returns `None` if this is a non-keyword identifier.
+fn get_real_ident_class(text: &str, edition: Edition, allow_path_keywords: bool) -> Option<Class> {
+    let ignore: &[&str] =
+        if allow_path_keywords { &["self", "Self", "super", "crate"] } else { &["self", "Self"] };
+    if ignore.iter().any(|k| *k == text) {
+        return None;
+    }
+    Some(match text {
+        "ref" | "mut" => Class::RefKeyWord,
+        "false" | "true" => Class::Bool,
+        _ if Symbol::intern(text).is_reserved(|| edition) => Class::KeyWord,
+        _ => return None,
+    })
+}
+
+/// This iterator comes from the same idea than "Peekable" except that it allows to "peek" more than
+/// just the next item by using `peek_next`. The `peek` method always returns the next item after
+/// the current one whereas `peek_next` will return the next item after the last one peeked.
+///
+/// You can use both `peek` and `peek_next` at the same time without problem.
+struct PeekIter<'a> {
+    stored: VecDeque<(TokenKind, &'a str)>,
+    /// This position is reinitialized when using `next`. It is used in `peek_next`.
+    peek_pos: usize,
+    iter: TokenIter<'a>,
+}
+
+impl<'a> PeekIter<'a> {
+    fn new(iter: TokenIter<'a>) -> Self {
+        Self { stored: VecDeque::new(), peek_pos: 0, iter }
+    }
+    /// Returns the next item after the current one. It doesn't interfer with `peek_next` output.
+    fn peek(&mut self) -> Option<&(TokenKind, &'a str)> {
+        if self.stored.is_empty() {
+            if let Some(next) = self.iter.next() {
+                self.stored.push_back(next);
+            }
+        }
+        self.stored.front()
+    }
+    /// Returns the next item after the last one peeked. It doesn't interfer with `peek` output.
+    fn peek_next(&mut self) -> Option<&(TokenKind, &'a str)> {
+        self.peek_pos += 1;
+        if self.peek_pos - 1 < self.stored.len() {
+            self.stored.get(self.peek_pos - 1)
+        } else if let Some(next) = self.iter.next() {
+            self.stored.push_back(next);
+            self.stored.back()
+        } else {
+            None
+        }
+    }
+}
+
+impl<'a> Iterator for PeekIter<'a> {
+    type Item = (TokenKind, &'a str);
+    fn next(&mut self) -> Option<Self::Item> {
+        self.peek_pos = 0;
+        if let Some(first) = self.stored.pop_front() { Some(first) } else { self.iter.next() }
+    }
+}
+
+/// Custom spans inserted into the source. Eg --scrape-examples uses this to highlight function calls
+struct Decorations {
+    starts: Vec<(u32, &'static str)>,
+    ends: Vec<u32>,
+}
+
+impl Decorations {
+    fn new(info: DecorationInfo) -> Self {
+        // Extract tuples (start, end, kind) into separate sequences of (start, kind) and (end).
+        let (mut starts, mut ends): (Vec<_>, Vec<_>) = info
+            .0
+            .into_iter()
+            .flat_map(|(kind, ranges)| ranges.into_iter().map(move |(lo, hi)| ((lo, kind), hi)))
+            .unzip();
+
+        // Sort the sequences in document order.
+        starts.sort_by_key(|(lo, _)| *lo);
+        ends.sort();
+
+        Decorations { starts, ends }
+    }
+}
+
+/// Processes program tokens, classifying strings of text by highlighting
+/// category (`Class`).
+struct Classifier<'a> {
+    tokens: PeekIter<'a>,
+    in_attribute: bool,
+    in_macro: bool,
+    in_macro_nonterminal: bool,
+    edition: Edition,
+    byte_pos: u32,
+    file_span: Span,
+    src: &'a str,
+    decorations: Option<Decorations>,
+}
+
+impl<'a> Classifier<'a> {
+    /// Takes as argument the source code to HTML-ify, the rust edition to use and the source code
+    /// file span which will be used later on by the `span_correspondance_map`.
+    fn new(
+        src: &str,
+        edition: Edition,
+        file_span: Span,
+        decoration_info: Option<DecorationInfo>,
+    ) -> Classifier<'_> {
+        let tokens = PeekIter::new(TokenIter { src });
+        let decorations = decoration_info.map(Decorations::new);
+        Classifier {
+            tokens,
+            in_attribute: false,
+            in_macro: false,
+            in_macro_nonterminal: false,
+            edition,
+            byte_pos: 0,
+            file_span,
+            src,
+            decorations,
+        }
+    }
+
+    /// Convenient wrapper to create a [`Span`] from a position in the file.
+    fn new_span(&self, lo: u32, text: &str) -> Span {
+        let hi = lo + text.len() as u32;
+        let file_lo = self.file_span.lo();
+        self.file_span.with_lo(file_lo + BytePos(lo)).with_hi(file_lo + BytePos(hi))
+    }
+
+    /// Concatenate colons and idents as one when possible.
+    fn get_full_ident_path(&mut self) -> Vec<(TokenKind, usize, usize)> {
+        let start = self.byte_pos as usize;
+        let mut pos = start;
+        let mut has_ident = false;
+        let edition = self.edition;
+
+        loop {
+            let mut nb = 0;
+            while let Some((TokenKind::Colon, _)) = self.tokens.peek() {
+                self.tokens.next();
+                nb += 1;
+            }
+            // Ident path can start with "::" but if we already have content in the ident path,
+            // the "::" is mandatory.
+            if has_ident && nb == 0 {
+                return vec![(TokenKind::Ident, start, pos)];
+            } else if nb != 0 && nb != 2 {
+                if has_ident {
+                    return vec![(TokenKind::Ident, start, pos), (TokenKind::Colon, pos, pos + nb)];
+                } else {
+                    return vec![(TokenKind::Colon, start, pos + nb)];
+                }
+            }
+
+            if let Some((None, text)) = self.tokens.peek().map(|(token, text)| {
+                if *token == TokenKind::Ident {
+                    let class = get_real_ident_class(text, edition, true);
+                    (class, text)
+                } else {
+                    // Doesn't matter which Class we put in here...
+                    (Some(Class::Comment), text)
+                }
+            }) {
+                // We only "add" the colon if there is an ident behind.
+                pos += text.len() + nb;
+                has_ident = true;
+                self.tokens.next();
+            } else if nb > 0 && has_ident {
+                return vec![(TokenKind::Ident, start, pos), (TokenKind::Colon, pos, pos + nb)];
+            } else if nb > 0 {
+                return vec![(TokenKind::Colon, start, start + nb)];
+            } else if has_ident {
+                return vec![(TokenKind::Ident, start, pos)];
+            } else {
+                return Vec::new();
+            }
+        }
+    }
+
+    /// Wraps the tokens iteration to ensure that the `byte_pos` is always correct.
+    ///
+    /// It returns the token's kind, the token as a string and its byte position in the source
+    /// string.
+    fn next(&mut self) -> Option<(TokenKind, &'a str, u32)> {
+        if let Some((kind, text)) = self.tokens.next() {
+            let before = self.byte_pos;
+            self.byte_pos += text.len() as u32;
+            Some((kind, text, before))
+        } else {
+            None
+        }
+    }
+
+    /// Exhausts the `Classifier` writing the output into `sink`.
+    ///
+    /// The general structure for this method is to iterate over each token,
+    /// possibly giving it an HTML span with a class specifying what flavor of
+    /// token is used.
+    fn highlight(mut self, sink: &mut dyn FnMut(Highlight<'a>)) {
+        loop {
+            if let Some(decs) = self.decorations.as_mut() {
+                let byte_pos = self.byte_pos;
+                let n_starts = decs.starts.iter().filter(|(i, _)| byte_pos >= *i).count();
+                for (_, kind) in decs.starts.drain(0..n_starts) {
+                    sink(Highlight::EnterSpan { class: Class::Decoration(kind) });
+                }
+
+                let n_ends = decs.ends.iter().filter(|i| byte_pos >= **i).count();
+                for _ in decs.ends.drain(0..n_ends) {
+                    sink(Highlight::ExitSpan);
+                }
+            }
+
+            if self
+                .tokens
+                .peek()
+                .map(|t| matches!(t.0, TokenKind::Colon | TokenKind::Ident))
+                .unwrap_or(false)
+            {
+                let tokens = self.get_full_ident_path();
+                for (token, start, end) in &tokens {
+                    let text = &self.src[*start..*end];
+                    self.advance(*token, text, sink, *start as u32);
+                    self.byte_pos += text.len() as u32;
+                }
+                if !tokens.is_empty() {
+                    continue;
+                }
+            }
+            if let Some((token, text, before)) = self.next() {
+                self.advance(token, text, sink, before);
+            } else {
+                break;
+            }
+        }
+    }
+
+    /// Single step of highlighting. This will classify `token`, but maybe also a couple of
+    /// following ones as well.
+    ///
+    /// `before` is the position of the given token in the `source` string and is used as "lo" byte
+    /// in case we want to try to generate a link for this token using the
+    /// `span_correspondance_map`.
+    fn advance(
+        &mut self,
+        token: TokenKind,
+        text: &'a str,
+        sink: &mut dyn FnMut(Highlight<'a>),
+        before: u32,
+    ) {
+        let lookahead = self.peek();
+        let no_highlight = |sink: &mut dyn FnMut(_)| sink(Highlight::Token { text, class: None });
+        let class = match token {
+            TokenKind::Whitespace => return no_highlight(sink),
+            TokenKind::LineComment { doc_style } | TokenKind::BlockComment { doc_style, .. } => {
+                if doc_style.is_some() {
+                    Class::DocComment
+                } else {
+                    Class::Comment
+                }
+            }
+            // Consider this as part of a macro invocation if there was a
+            // leading identifier.
+            TokenKind::Bang if self.in_macro => {
+                self.in_macro = false;
+                sink(Highlight::Token { text, class: None });
+                sink(Highlight::ExitSpan);
+                return;
+            }
+
+            // Assume that '&' or '*' is the reference or dereference operator
+            // or a reference or pointer type. Unless, of course, it looks like
+            // a logical and or a multiplication operator: `&&` or `* `.
+            TokenKind::Star => match self.tokens.peek() {
+                Some((TokenKind::Whitespace, _)) => Class::Op,
+                Some((TokenKind::Ident, "mut")) => {
+                    self.next();
+                    sink(Highlight::Token { text: "*mut", class: Some(Class::RefKeyWord) });
+                    return;
+                }
+                Some((TokenKind::Ident, "const")) => {
+                    self.next();
+                    sink(Highlight::Token { text: "*const", class: Some(Class::RefKeyWord) });
+                    return;
+                }
+                _ => Class::RefKeyWord,
+            },
+            TokenKind::And => match self.tokens.peek() {
+                Some((TokenKind::And, _)) => {
+                    self.next();
+                    sink(Highlight::Token { text: "&&", class: Some(Class::Op) });
+                    return;
+                }
+                Some((TokenKind::Eq, _)) => {
+                    self.next();
+                    sink(Highlight::Token { text: "&=", class: Some(Class::Op) });
+                    return;
+                }
+                Some((TokenKind::Whitespace, _)) => Class::Op,
+                Some((TokenKind::Ident, "mut")) => {
+                    self.next();
+                    sink(Highlight::Token { text: "&mut", class: Some(Class::RefKeyWord) });
+                    return;
+                }
+                _ => Class::RefKeyWord,
+            },
+
+            // These can either be operators, or arrows.
+            TokenKind::Eq => match lookahead {
+                Some(TokenKind::Eq) => {
+                    self.next();
+                    sink(Highlight::Token { text: "==", class: Some(Class::Op) });
+                    return;
+                }
+                Some(TokenKind::Gt) => {
+                    self.next();
+                    sink(Highlight::Token { text: "=>", class: None });
+                    return;
+                }
+                _ => Class::Op,
+            },
+            TokenKind::Minus if lookahead == Some(TokenKind::Gt) => {
+                self.next();
+                sink(Highlight::Token { text: "->", class: None });
+                return;
+            }
+
+            // Other operators.
+            TokenKind::Minus
+            | TokenKind::Plus
+            | TokenKind::Or
+            | TokenKind::Slash
+            | TokenKind::Caret
+            | TokenKind::Percent
+            | TokenKind::Bang
+            | TokenKind::Lt
+            | TokenKind::Gt => Class::Op,
+
+            // Miscellaneous, no highlighting.
+            TokenKind::Dot
+            | TokenKind::Semi
+            | TokenKind::Comma
+            | TokenKind::OpenParen
+            | TokenKind::CloseParen
+            | TokenKind::OpenBrace
+            | TokenKind::CloseBrace
+            | TokenKind::OpenBracket
+            | TokenKind::At
+            | TokenKind::Tilde
+            | TokenKind::Colon
+            | TokenKind::Unknown => return no_highlight(sink),
+
+            TokenKind::Question => Class::QuestionMark,
+
+            TokenKind::Dollar => match lookahead {
+                Some(TokenKind::Ident) => {
+                    self.in_macro_nonterminal = true;
+                    Class::MacroNonTerminal
+                }
+                _ => return no_highlight(sink),
+            },
+
+            // This might be the start of an attribute. We're going to want to
+            // continue highlighting it as an attribute until the ending ']' is
+            // seen, so skip out early. Down below we terminate the attribute
+            // span when we see the ']'.
+            TokenKind::Pound => {
+                match lookahead {
+                    // Case 1: #![inner_attribute]
+                    Some(TokenKind::Bang) => {
+                        self.next();
+                        if let Some(TokenKind::OpenBracket) = self.peek() {
+                            self.in_attribute = true;
+                            sink(Highlight::EnterSpan { class: Class::Attribute });
+                        }
+                        sink(Highlight::Token { text: "#", class: None });
+                        sink(Highlight::Token { text: "!", class: None });
+                        return;
+                    }
+                    // Case 2: #[outer_attribute]
+                    Some(TokenKind::OpenBracket) => {
+                        self.in_attribute = true;
+                        sink(Highlight::EnterSpan { class: Class::Attribute });
+                    }
+                    _ => (),
+                }
+                return no_highlight(sink);
+            }
+            TokenKind::CloseBracket => {
+                if self.in_attribute {
+                    self.in_attribute = false;
+                    sink(Highlight::Token { text: "]", class: None });
+                    sink(Highlight::ExitSpan);
+                    return;
+                }
+                return no_highlight(sink);
+            }
+            TokenKind::Literal { kind, .. } => match kind {
+                // Text literals.
+                LiteralKind::Byte { .. }
+                | LiteralKind::Char { .. }
+                | LiteralKind::Str { .. }
+                | LiteralKind::ByteStr { .. }
+                | LiteralKind::RawStr { .. }
+                | LiteralKind::RawByteStr { .. } => Class::String,
+                // Number literals.
+                LiteralKind::Float { .. } | LiteralKind::Int { .. } => Class::Number,
+            },
+            TokenKind::Ident | TokenKind::RawIdent if lookahead == Some(TokenKind::Bang) => {
+                self.in_macro = true;
+                sink(Highlight::EnterSpan { class: Class::Macro(self.new_span(before, text)) });
+                sink(Highlight::Token { text, class: None });
+                return;
+            }
+            TokenKind::Ident => match get_real_ident_class(text, self.edition, false) {
+                None => match text {
+                    "Option" | "Result" => Class::PreludeTy,
+                    "Some" | "None" | "Ok" | "Err" => Class::PreludeVal,
+                    // "union" is a weak keyword and is only considered as a keyword when declaring
+                    // a union type.
+                    "union" if self.check_if_is_union_keyword() => Class::KeyWord,
+                    _ if self.in_macro_nonterminal => {
+                        self.in_macro_nonterminal = false;
+                        Class::MacroNonTerminal
+                    }
+                    "self" | "Self" => Class::Self_(self.new_span(before, text)),
+                    _ => Class::Ident(self.new_span(before, text)),
+                },
+                Some(c) => c,
+            },
+            TokenKind::RawIdent | TokenKind::UnknownPrefix | TokenKind::InvalidIdent => {
+                Class::Ident(self.new_span(before, text))
+            }
+            TokenKind::Lifetime { .. } => Class::Lifetime,
+        };
+        // Anything that didn't return above is the simple case where we the
+        // class just spans a single token, so we can use the `string` method.
+        sink(Highlight::Token { text, class: Some(class) });
+    }
+
+    fn peek(&mut self) -> Option<TokenKind> {
+        self.tokens.peek().map(|(token_kind, _text)| *token_kind)
+    }
+
+    fn check_if_is_union_keyword(&mut self) -> bool {
+        while let Some(kind) = self.tokens.peek_next().map(|(token_kind, _text)| token_kind) {
+            if *kind == TokenKind::Whitespace {
+                continue;
+            }
+            return *kind == TokenKind::Ident;
+        }
+        false
+    }
+}
+
+/// Called when we start processing a span of text that should be highlighted.
+/// The `Class` argument specifies how it should be highlighted.
+fn enter_span(
+    out: &mut Buffer,
+    klass: Class,
+    href_context: &Option<HrefContext<'_, '_, '_>>,
+) -> &'static str {
+    string_without_closing_tag(out, "", Some(klass), href_context).expect(
+        "internal error: enter_span was called with Some(klass) but did not return a \
+            closing HTML tag",
+    )
+}
+
+/// Called at the end of a span of highlighted text.
+fn exit_span(out: &mut Buffer, closing_tag: &str) {
+    out.write_str(closing_tag);
+}
+
+/// Called for a span of text. If the text should be highlighted differently
+/// from the surrounding text, then the `Class` argument will be a value other
+/// than `None`.
+///
+/// The following sequences of callbacks are equivalent:
+/// ```plain
+///     enter_span(Foo), string("text", None), exit_span()
+///     string("text", Foo)
+/// ```
+///
+/// The latter can be thought of as a shorthand for the former, which is more
+/// flexible.
+///
+/// Note that if `context` is not `None` and that the given `klass` contains a `Span`, the function
+/// will then try to find this `span` in the `span_correspondance_map`. If found, it'll then
+/// generate a link for this element (which corresponds to where its definition is located).
+fn string<T: Display>(
+    out: &mut Buffer,
+    text: T,
+    klass: Option<Class>,
+    href_context: &Option<HrefContext<'_, '_, '_>>,
+) {
+    if let Some(closing_tag) = string_without_closing_tag(out, text, klass, href_context) {
+        out.write_str(closing_tag);
+    }
+}
+
+/// This function writes `text` into `out` with some modifications depending on `klass`:
+///
+/// * If `klass` is `None`, `text` is written into `out` with no modification.
+/// * If `klass` is `Some` but `klass.get_span()` is `None`, it writes the text wrapped in a
+///   `<span>` with the provided `klass`.
+/// * If `klass` is `Some` and has a [`rustc_span::Span`], it then tries to generate a link (`<a>`
+///   element) by retrieving the link information from the `span_correspondance_map` that was filled
+///   in `span_map.rs::collect_spans_and_sources`. If it cannot retrieve the information, then it's
+///   the same as the second point (`klass` is `Some` but doesn't have a [`rustc_span::Span`]).
+fn string_without_closing_tag<T: Display>(
+    out: &mut Buffer,
+    text: T,
+    klass: Option<Class>,
+    href_context: &Option<HrefContext<'_, '_, '_>>,
+) -> Option<&'static str> {
+    let Some(klass) = klass
+    else {
+        write!(out, "{}", text);
+        return None;
+    };
+    let Some(def_span) = klass.get_span()
+    else {
+        write!(out, "<span class=\"{}\">{}", klass.as_html(), text);
+        return Some("</span>");
+    };
+
+    let mut text_s = text.to_string();
+    if text_s.contains("::") {
+        text_s = text_s.split("::").intersperse("::").fold(String::new(), |mut path, t| {
+            match t {
+                "self" | "Self" => write!(
+                    &mut path,
+                    "<span class=\"{}\">{}</span>",
+                    Class::Self_(DUMMY_SP).as_html(),
+                    t
+                ),
+                "crate" | "super" => {
+                    write!(&mut path, "<span class=\"{}\">{}</span>", Class::KeyWord.as_html(), t)
+                }
+                t => write!(&mut path, "{}", t),
+            }
+            .expect("Failed to build source HTML path");
+            path
+        });
+    }
+    if let Some(href_context) = href_context {
+        if let Some(href) =
+            href_context.context.shared.span_correspondance_map.get(&def_span).and_then(|href| {
+                let context = href_context.context;
+                // FIXME: later on, it'd be nice to provide two links (if possible) for all items:
+                // one to the documentation page and one to the source definition.
+                // FIXME: currently, external items only generate a link to their documentation,
+                // a link to their definition can be generated using this:
+                // https://github.com/rust-lang/rust/blob/60f1a2fc4b535ead9c85ce085fdce49b1b097531/src/librustdoc/html/render/context.rs#L315-L338
+                match href {
+                    LinkFromSrc::Local(span) => context
+                        .href_from_span(*span, true)
+                        .map(|s| format!("{}{}", href_context.root_path, s)),
+                    LinkFromSrc::External(def_id) => {
+                        format::href_with_root_path(*def_id, context, Some(href_context.root_path))
+                            .ok()
+                            .map(|(url, _, _)| url)
+                    }
+                    LinkFromSrc::Primitive(prim) => format::href_with_root_path(
+                        PrimitiveType::primitive_locations(context.tcx())[prim],
+                        context,
+                        Some(href_context.root_path),
+                    )
+                    .ok()
+                    .map(|(url, _, _)| url),
+                }
+            })
+        {
+            write!(out, "<a class=\"{}\" href=\"{}\">{}", klass.as_html(), href, text_s);
+            return Some("</a>");
+        }
+    }
+    write!(out, "<span class=\"{}\">{}", klass.as_html(), text_s);
+    Some("</span>")
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/src/librustdoc/html/highlight/fixtures/decorations.html b/src/librustdoc/html/highlight/fixtures/decorations.html
new file mode 100644
index 000000000..45f567880
--- /dev/null
+++ b/src/librustdoc/html/highlight/fixtures/decorations.html
@@ -0,0 +1,2 @@
+<span class="example"><span class="kw">let</span> <span class="ident">x</span> <span class="op">=</span> <span class="number">1</span>;</span>
+<span class="kw">let</span> <span class="ident">y</span> <span class="op">=</span> <span class="number">2</span>;
\ No newline at end of file
diff --git a/src/librustdoc/html/highlight/fixtures/dos_line.html b/src/librustdoc/html/highlight/fixtures/dos_line.html
new file mode 100644
index 000000000..1c8dbffe7
--- /dev/null
+++ b/src/librustdoc/html/highlight/fixtures/dos_line.html
@@ -0,0 +1,3 @@
+<span class="kw">pub</span> <span class="kw">fn</span> <span class="ident">foo</span>() {
+<span class="macro">println!</span>(<span class="string">&quot;foo&quot;</span>);
+}
diff --git a/src/librustdoc/html/highlight/fixtures/highlight.html b/src/librustdoc/html/highlight/fixtures/highlight.html
new file mode 100644
index 000000000..abc2db179
--- /dev/null
+++ b/src/librustdoc/html/highlight/fixtures/highlight.html
@@ -0,0 +1,4 @@
+<span class="kw">use</span> <span class="ident"><span class="kw">crate</span>::a::foo</span>;
+<span class="kw">use</span> <span class="ident"><span class="self">self</span>::whatever</span>;
+<span class="kw">let</span> <span class="ident">x</span> <span class="op">=</span> <span class="ident"><span class="kw">super</span>::b::foo</span>;
+<span class="kw">let</span> <span class="ident">y</span> <span class="op">=</span> <span class="ident"><span class="self">Self</span>::whatever</span>;
\ No newline at end of file
diff --git a/src/librustdoc/html/highlight/fixtures/sample.html b/src/librustdoc/html/highlight/fixtures/sample.html
new file mode 100644
index 000000000..b117a12e3
--- /dev/null
+++ b/src/librustdoc/html/highlight/fixtures/sample.html
@@ -0,0 +1,37 @@
+
+<style>
+.kw { color: #8959A8; }
+.kw-2, .prelude-ty { color: #4271AE; }
+.number, .string { color: #718C00; }
+.self, .bool-val, .prelude-val, .attribute, .attribute .ident { color: #C82829; }
+.macro, .macro-nonterminal { color: #3E999F; }
+.lifetime { color: #B76514; }
+.question-mark { color: #ff9011; }
+</style>
+<pre><code><span class="attribute">#![<span class="ident">crate_type</span> <span class="op">=</span> <span class="string">&quot;lib&quot;</span>]</span>
+
+<span class="kw">use</span> <span class="ident">std::path</span>::{<span class="ident">Path</span>, <span class="ident">PathBuf</span>};
+
+<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">target_os</span> <span class="op">=</span> <span class="string">&quot;linux&quot;</span>)]</span>
+<span class="kw">fn</span> <span class="ident">main</span>() -&gt; () {
+    <span class="kw">let</span> <span class="ident">foo</span> <span class="op">=</span> <span class="bool-val">true</span> <span class="op">&amp;&amp;</span> <span class="bool-val">false</span> <span class="op">|</span><span class="op">|</span> <span class="bool-val">true</span>;
+    <span class="kw">let</span> <span class="kw">_</span>: <span class="kw-2">*const</span> () <span class="op">=</span> <span class="number">0</span>;
+    <span class="kw">let</span> <span class="kw">_</span> <span class="op">=</span> <span class="kw-2">&amp;</span><span class="ident">foo</span>;
+    <span class="kw">let</span> <span class="kw">_</span> <span class="op">=</span> <span class="op">&amp;&amp;</span><span class="ident">foo</span>;
+    <span class="kw">let</span> <span class="kw">_</span> <span class="op">=</span> <span class="kw-2">*</span><span class="ident">foo</span>;
+    <span class="macro">mac!</span>(<span class="ident">foo</span>, <span class="kw-2">&amp;mut</span> <span class="ident">bar</span>);
+    <span class="macro">assert!</span>(<span class="self">self</span>.<span class="ident">length</span> <span class="op">&lt;</span> <span class="ident">N</span> <span class="op">&amp;&amp;</span> <span class="ident">index</span> <span class="op">&lt;</span><span class="op">=</span> <span class="self">self</span>.<span class="ident">length</span>);
+    <span class="ident">::std::env::var</span>(<span class="string">&quot;gateau&quot;</span>).<span class="ident">is_ok</span>();
+    <span class="attribute">#[<span class="ident">rustfmt::skip</span>]</span>
+    <span class="kw">let</span> <span class="ident">s</span>:<span class="ident">std::path::PathBuf</span> <span class="op">=</span> <span class="ident">std::path::PathBuf::new</span>();
+    <span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">s</span> <span class="op">=</span> <span class="ident">String::new</span>();
+
+    <span class="kw">match</span> <span class="kw-2">&amp;</span><span class="ident">s</span> {
+        <span class="kw-2">ref</span> <span class="kw-2">mut</span> <span class="ident">x</span> =&gt; {}
+    }
+}
+
+<span class="macro">macro_rules!</span> <span class="ident">bar</span> {
+    (<span class="macro-nonterminal">$</span><span class="macro-nonterminal">foo</span>:<span class="ident">tt</span>) =&gt; {};
+}
+</code></pre>
diff --git a/src/librustdoc/html/highlight/fixtures/sample.rs b/src/librustdoc/html/highlight/fixtures/sample.rs
new file mode 100644
index 000000000..fbfdc6767
--- /dev/null
+++ b/src/librustdoc/html/highlight/fixtures/sample.rs
@@ -0,0 +1,26 @@
+#![crate_type = "lib"]
+
+use std::path::{Path, PathBuf};
+
+#[cfg(target_os = "linux")]
+fn main() -> () {
+    let foo = true && false || true;
+    let _: *const () = 0;
+    let _ = &foo;
+    let _ = &&foo;
+    let _ = *foo;
+    mac!(foo, &mut bar);
+    assert!(self.length < N && index <= self.length);
+    ::std::env::var("gateau").is_ok();
+    #[rustfmt::skip]
+    let s:std::path::PathBuf = std::path::PathBuf::new();
+    let mut s = String::new();
+
+    match &s {
+        ref mut x => {}
+    }
+}
+
+macro_rules! bar {
+    ($foo:tt) => {};
+}
diff --git a/src/librustdoc/html/highlight/fixtures/union.html b/src/librustdoc/html/highlight/fixtures/union.html
new file mode 100644
index 000000000..c0acf31a0
--- /dev/null
+++ b/src/librustdoc/html/highlight/fixtures/union.html
@@ -0,0 +1,8 @@
+<span class="kw">union</span> <span class="ident">Foo</span> {
+    <span class="ident">i</span>: <span class="ident">i8</span>,
+    <span class="ident">u</span>: <span class="ident">i8</span>,
+}
+
+<span class="kw">fn</span> <span class="ident">main</span>() {
+    <span class="kw">let</span> <span class="ident">union</span> <span class="op">=</span> <span class="number">0</span>;
+}
diff --git a/src/librustdoc/html/highlight/fixtures/union.rs b/src/librustdoc/html/highlight/fixtures/union.rs
new file mode 100644
index 000000000..269ee115d
--- /dev/null
+++ b/src/librustdoc/html/highlight/fixtures/union.rs
@@ -0,0 +1,8 @@
+union Foo {
+    i: i8,
+    u: i8,
+}
+
+fn main() {
+    let union = 0;
+}
diff --git a/src/librustdoc/html/highlight/tests.rs b/src/librustdoc/html/highlight/tests.rs
new file mode 100644
index 000000000..1fea7e983
--- /dev/null
+++ b/src/librustdoc/html/highlight/tests.rs
@@ -0,0 +1,81 @@
+use super::{write_code, DecorationInfo};
+use crate::html::format::Buffer;
+use expect_test::expect_file;
+use rustc_data_structures::fx::FxHashMap;
+use rustc_span::create_default_session_globals_then;
+use rustc_span::edition::Edition;
+
+const STYLE: &str = r#"
+<style>
+.kw { color: #8959A8; }
+.kw-2, .prelude-ty { color: #4271AE; }
+.number, .string { color: #718C00; }
+.self, .bool-val, .prelude-val, .attribute, .attribute .ident { color: #C82829; }
+.macro, .macro-nonterminal { color: #3E999F; }
+.lifetime { color: #B76514; }
+.question-mark { color: #ff9011; }
+</style>
+"#;
+
+#[test]
+fn test_html_highlighting() {
+    create_default_session_globals_then(|| {
+        let src = include_str!("fixtures/sample.rs");
+        let html = {
+            let mut out = Buffer::new();
+            write_code(&mut out, src, Edition::Edition2018, None, None);
+            format!("{}<pre><code>{}</code></pre>\n", STYLE, out.into_inner())
+        };
+        expect_file!["fixtures/sample.html"].assert_eq(&html);
+    });
+}
+
+#[test]
+fn test_dos_backline() {
+    create_default_session_globals_then(|| {
+        let src = "pub fn foo() {\r\n\
+    println!(\"foo\");\r\n\
+}\r\n";
+        let mut html = Buffer::new();
+        write_code(&mut html, src, Edition::Edition2018, None, None);
+        expect_file!["fixtures/dos_line.html"].assert_eq(&html.into_inner());
+    });
+}
+
+#[test]
+fn test_keyword_highlight() {
+    create_default_session_globals_then(|| {
+        let src = "use crate::a::foo;
+use self::whatever;
+let x = super::b::foo;
+let y = Self::whatever;";
+
+        let mut html = Buffer::new();
+        write_code(&mut html, src, Edition::Edition2018, None, None);
+        expect_file!["fixtures/highlight.html"].assert_eq(&html.into_inner());
+    });
+}
+
+#[test]
+fn test_union_highlighting() {
+    create_default_session_globals_then(|| {
+        let src = include_str!("fixtures/union.rs");
+        let mut html = Buffer::new();
+        write_code(&mut html, src, Edition::Edition2018, None, None);
+        expect_file!["fixtures/union.html"].assert_eq(&html.into_inner());
+    });
+}
+
+#[test]
+fn test_decorations() {
+    create_default_session_globals_then(|| {
+        let src = "let x = 1;
+let y = 2;";
+        let mut decorations = FxHashMap::default();
+        decorations.insert("example", vec![(0, 10)]);
+
+        let mut html = Buffer::new();
+        write_code(&mut html, src, Edition::Edition2018, None, Some(DecorationInfo(decorations)));
+        expect_file!["fixtures/decorations.html"].assert_eq(&html.into_inner());
+    });
+}
diff --git a/src/librustdoc/html/layout.rs b/src/librustdoc/html/layout.rs
new file mode 100644
index 000000000..7d6d4b71e
--- /dev/null
+++ b/src/librustdoc/html/layout.rs
@@ -0,0 +1,103 @@
+use std::path::PathBuf;
+
+use rustc_data_structures::fx::FxHashMap;
+
+use crate::error::Error;
+use crate::externalfiles::ExternalHtml;
+use crate::html::format::{Buffer, Print};
+use crate::html::render::{ensure_trailing_slash, StylePath};
+
+use askama::Template;
+
+#[derive(Clone)]
+pub(crate) struct Layout {
+    pub(crate) logo: String,
+    pub(crate) favicon: String,
+    pub(crate) external_html: ExternalHtml,
+    pub(crate) default_settings: FxHashMap<String, String>,
+    pub(crate) krate: String,
+    /// The given user css file which allow to customize the generated
+    /// documentation theme.
+    pub(crate) css_file_extension: Option<PathBuf>,
+    /// If true, then scrape-examples.js will be included in the output HTML file
+    pub(crate) scrape_examples_extension: bool,
+}
+
+pub(crate) struct Page<'a> {
+    pub(crate) title: &'a str,
+    pub(crate) css_class: &'a str,
+    pub(crate) root_path: &'a str,
+    pub(crate) static_root_path: Option<&'a str>,
+    pub(crate) description: &'a str,
+    pub(crate) keywords: &'a str,
+    pub(crate) resource_suffix: &'a str,
+}
+
+impl<'a> Page<'a> {
+    pub(crate) fn get_static_root_path(&self) -> &str {
+        self.static_root_path.unwrap_or(self.root_path)
+    }
+}
+
+#[derive(Template)]
+#[template(path = "page.html")]
+struct PageLayout<'a> {
+    static_root_path: &'a str,
+    page: &'a Page<'a>,
+    layout: &'a Layout,
+    themes: Vec<String>,
+    sidebar: String,
+    content: String,
+    krate_with_trailing_slash: String,
+    pub(crate) rustdoc_version: &'a str,
+}
+
+pub(crate) fn render<T: Print, S: Print>(
+    layout: &Layout,
+    page: &Page<'_>,
+    sidebar: S,
+    t: T,
+    style_files: &[StylePath],
+) -> String {
+    let static_root_path = page.get_static_root_path();
+    let krate_with_trailing_slash = ensure_trailing_slash(&layout.krate).to_string();
+    let mut themes: Vec<String> = style_files
+        .iter()
+        .map(StylePath::basename)
+        .collect::<Result<_, Error>>()
+        .unwrap_or_default();
+    themes.sort();
+    let rustdoc_version = rustc_interface::util::version_str().unwrap_or("unknown version");
+    let content = Buffer::html().to_display(t); // Note: This must happen before making the sidebar.
+    let sidebar = Buffer::html().to_display(sidebar);
+    PageLayout {
+        static_root_path,
+        page,
+        layout,
+        themes,
+        sidebar,
+        content,
+        krate_with_trailing_slash,
+        rustdoc_version,
+    }
+    .render()
+    .unwrap()
+}
+
+pub(crate) fn redirect(url: &str) -> String {
+    // <script> triggers a redirect before refresh, so this is fine.
+    format!(
+        r##"<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta http-equiv="refresh" content="0;URL={url}">
+    <title>Redirection</title>
+</head>
+<body>
+    <p>Redirecting to <a href="{url}">{url}</a>...</p>
+    <script>location.replace("{url}" + location.search + location.hash);</script>
+</body>
+</html>"##,
+        url = url,
+    )
+}
diff --git a/src/librustdoc/html/length_limit.rs b/src/librustdoc/html/length_limit.rs
new file mode 100644
index 000000000..bbdc91c8d
--- /dev/null
+++ b/src/librustdoc/html/length_limit.rs
@@ -0,0 +1,119 @@
+//! See [`HtmlWithLimit`].
+
+use std::fmt::Write;
+use std::ops::ControlFlow;
+
+use crate::html::escape::Escape;
+
+/// A buffer that allows generating HTML with a length limit.
+///
+/// This buffer ensures that:
+///
+/// * all tags are closed,
+/// * tags are closed in the reverse order of when they were opened (i.e., the correct HTML order),
+/// * no tags are left empty (e.g., `<em></em>`) due to the length limit being reached,
+/// * all text is escaped.
+#[derive(Debug)]
+pub(super) struct HtmlWithLimit {
+    buf: String,
+    len: usize,
+    limit: usize,
+    /// A list of tags that have been requested to be opened via [`Self::open_tag()`]
+    /// but have not actually been pushed to `buf` yet. This ensures that tags are not
+    /// left empty (e.g., `<em></em>`) due to the length limit being reached.
+    queued_tags: Vec<&'static str>,
+    /// A list of all tags that have been opened but not yet closed.
+    unclosed_tags: Vec<&'static str>,
+}
+
+impl HtmlWithLimit {
+    /// Create a new buffer, with a limit of `length_limit`.
+    pub(super) fn new(length_limit: usize) -> Self {
+        let buf = if length_limit > 1000 {
+            // If the length limit is really large, don't preallocate tons of memory.
+            String::new()
+        } else {
+            // The length limit is actually a good heuristic for initial allocation size.
+            // Measurements showed that using it as the initial capacity ended up using less memory
+            // than `String::new`.
+            // See https://github.com/rust-lang/rust/pull/88173#discussion_r692531631 for more.
+            String::with_capacity(length_limit)
+        };
+        Self {
+            buf,
+            len: 0,
+            limit: length_limit,
+            unclosed_tags: Vec::new(),
+            queued_tags: Vec::new(),
+        }
+    }
+
+    /// 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.buf
+    }
+
+    /// Write some plain text to the buffer, escaping as needed.
+    ///
+    /// This function skips writing the text if the length limit was reached
+    /// and returns [`ControlFlow::Break`].
+    pub(super) fn push(&mut self, text: &str) -> ControlFlow<(), ()> {
+        if self.len + text.len() > self.limit {
+            return ControlFlow::BREAK;
+        }
+
+        self.flush_queue();
+        write!(self.buf, "{}", Escape(text)).unwrap();
+        self.len += text.len();
+
+        ControlFlow::CONTINUE
+    }
+
+    /// Open an HTML tag.
+    ///
+    /// **Note:** HTML attributes have not yet been implemented.
+    /// This function will panic if called with a non-alphabetic `tag_name`.
+    pub(super) fn open_tag(&mut self, tag_name: &'static str) {
+        assert!(
+            tag_name.chars().all(|c| ('a'..='z').contains(&c)),
+            "tag_name contained non-alphabetic chars: {:?}",
+            tag_name
+        );
+        self.queued_tags.push(tag_name);
+    }
+
+    /// Close the most recently opened HTML tag.
+    pub(super) fn close_tag(&mut self) {
+        match self.unclosed_tags.pop() {
+            // Close the most recently opened tag.
+            Some(tag_name) => write!(self.buf, "</{}>", tag_name).unwrap(),
+            // 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`.
+            None => {}
+        }
+    }
+
+    /// Write all queued tags and add them to the `unclosed_tags` list.
+    fn flush_queue(&mut self) {
+        for tag_name in self.queued_tags.drain(..) {
+            write!(self.buf, "<{}>", tag_name).unwrap();
+
+            self.unclosed_tags.push(tag_name);
+        }
+    }
+
+    /// Close all unclosed tags.
+    fn close_all_tags(&mut self) {
+        while !self.unclosed_tags.is_empty() {
+            self.close_tag();
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/src/librustdoc/html/length_limit/tests.rs b/src/librustdoc/html/length_limit/tests.rs
new file mode 100644
index 000000000..2d02b8a16
--- /dev/null
+++ b/src/librustdoc/html/length_limit/tests.rs
@@ -0,0 +1,120 @@
+use super::*;
+
+#[test]
+fn empty() {
+    assert_eq!(HtmlWithLimit::new(0).finish(), "");
+    assert_eq!(HtmlWithLimit::new(60).finish(), "");
+}
+
+#[test]
+fn basic() {
+    let mut buf = HtmlWithLimit::new(60);
+    buf.push("Hello ");
+    buf.open_tag("em");
+    buf.push("world");
+    buf.close_tag();
+    buf.push("!");
+    assert_eq!(buf.finish(), "Hello <em>world</em>!");
+}
+
+#[test]
+fn no_tags() {
+    let mut buf = HtmlWithLimit::new(60);
+    buf.push("Hello");
+    buf.push(" world!");
+    assert_eq!(buf.finish(), "Hello world!");
+}
+
+#[test]
+fn limit_0() {
+    let mut buf = HtmlWithLimit::new(0);
+    buf.push("Hello ");
+    buf.open_tag("em");
+    buf.push("world");
+    buf.close_tag();
+    buf.push("!");
+    assert_eq!(buf.finish(), "");
+}
+
+#[test]
+fn exactly_limit() {
+    let mut buf = HtmlWithLimit::new(12);
+    buf.push("Hello ");
+    buf.open_tag("em");
+    buf.push("world");
+    buf.close_tag();
+    buf.push("!");
+    assert_eq!(buf.finish(), "Hello <em>world</em>!");
+}
+
+#[test]
+fn multiple_nested_tags() {
+    let mut buf = HtmlWithLimit::new(60);
+    buf.open_tag("p");
+    buf.push("This is a ");
+    buf.open_tag("em");
+    buf.push("paragraph");
+    buf.open_tag("strong");
+    buf.push("!");
+    buf.close_tag();
+    buf.close_tag();
+    buf.close_tag();
+    assert_eq!(buf.finish(), "<p>This is a <em>paragraph<strong>!</strong></em></p>");
+}
+
+#[test]
+fn forgot_to_close_tags() {
+    let mut buf = HtmlWithLimit::new(60);
+    buf.open_tag("p");
+    buf.push("This is a ");
+    buf.open_tag("em");
+    buf.push("paragraph");
+    buf.open_tag("strong");
+    buf.push("!");
+    assert_eq!(buf.finish(), "<p>This is a <em>paragraph<strong>!</strong></em></p>");
+}
+
+#[test]
+fn past_the_limit() {
+    let mut buf = HtmlWithLimit::new(20);
+    buf.open_tag("p");
+    (0..10).try_for_each(|n| {
+        buf.open_tag("strong");
+        buf.push("word#")?;
+        buf.push(&n.to_string())?;
+        buf.close_tag();
+        ControlFlow::CONTINUE
+    });
+    buf.close_tag();
+    assert_eq!(
+        buf.finish(),
+        "<p>\
+             <strong>word#0</strong>\
+             <strong>word#1</strong>\
+             <strong>word#2</strong>\
+             </p>"
+    );
+}
+
+#[test]
+fn quickly_past_the_limit() {
+    let mut buf = HtmlWithLimit::new(6);
+    buf.open_tag("p");
+    buf.push("Hello");
+    buf.push(" World");
+    // intentionally not closing <p> before finishing
+    assert_eq!(buf.finish(), "<p>Hello</p>");
+}
+
+#[test]
+fn close_too_many() {
+    let mut buf = HtmlWithLimit::new(60);
+    buf.open_tag("p");
+    buf.push("Hello");
+    buf.close_tag();
+    // 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();
+    assert_eq!(buf.finish(), "<p>Hello</p>");
+}
diff --git a/src/librustdoc/html/markdown.rs b/src/librustdoc/html/markdown.rs
new file mode 100644
index 000000000..52a2effca
--- /dev/null
+++ b/src/librustdoc/html/markdown.rs
@@ -0,0 +1,1510 @@
+//! Markdown formatting for rustdoc.
+//!
+//! This module implements markdown formatting through the pulldown-cmark library.
+//!
+//! ```
+//! #![feature(rustc_private)]
+//!
+//! extern crate rustc_span;
+//!
+//! use rustc_span::edition::Edition;
+//! use rustdoc::html::markdown::{HeadingOffset, IdMap, Markdown, ErrorCodes};
+//!
+//! let s = "My *markdown* _text_";
+//! let mut id_map = IdMap::new();
+//! let md = Markdown {
+//!     content: s,
+//!     links: &[],
+//!     ids: &mut id_map,
+//!     error_codes: ErrorCodes::Yes,
+//!     edition: Edition::Edition2015,
+//!     playground: &None,
+//!     heading_offset: HeadingOffset::H2,
+//! };
+//! let html = md.into_string();
+//! // ... something using html
+//! ```
+
+use rustc_data_structures::fx::FxHashMap;
+use rustc_hir::def_id::DefId;
+use rustc_hir::HirId;
+use rustc_middle::ty::TyCtxt;
+use rustc_span::edition::Edition;
+use rustc_span::Span;
+
+use once_cell::sync::Lazy;
+use std::borrow::Cow;
+use std::cell::RefCell;
+use std::collections::VecDeque;
+use std::default::Default;
+use std::fmt::Write;
+use std::ops::{ControlFlow, Range};
+use std::str;
+
+use crate::clean::RenderedLink;
+use crate::doctest;
+use crate::html::escape::Escape;
+use crate::html::format::Buffer;
+use crate::html::highlight;
+use crate::html::length_limit::HtmlWithLimit;
+use crate::html::toc::TocBuilder;
+
+use pulldown_cmark::{
+    html, BrokenLink, CodeBlockKind, CowStr, Event, LinkType, Options, Parser, Tag,
+};
+
+#[cfg(test)]
+mod tests;
+
+const MAX_HEADER_LEVEL: u32 = 6;
+
+/// Options for rendering Markdown in the main body of documentation.
+pub(crate) fn main_body_opts() -> Options {
+    Options::ENABLE_TABLES
+        | Options::ENABLE_FOOTNOTES
+        | Options::ENABLE_STRIKETHROUGH
+        | Options::ENABLE_TASKLISTS
+        | Options::ENABLE_SMART_PUNCTUATION
+}
+
+/// Options for rendering Markdown in summaries (e.g., in search results).
+pub(crate) fn summary_opts() -> Options {
+    Options::ENABLE_TABLES
+        | Options::ENABLE_FOOTNOTES
+        | Options::ENABLE_STRIKETHROUGH
+        | Options::ENABLE_TASKLISTS
+        | Options::ENABLE_SMART_PUNCTUATION
+}
+
+#[derive(Debug, Clone, Copy)]
+pub enum HeadingOffset {
+    H1 = 0,
+    H2,
+    H3,
+    H4,
+    H5,
+    H6,
+}
+
+/// When `to_string` is called, this struct will emit the HTML corresponding to
+/// the rendered version of the contained markdown string.
+pub struct Markdown<'a> {
+    pub content: &'a str,
+    /// A list of link replacements.
+    pub links: &'a [RenderedLink],
+    /// The current list of used header IDs.
+    pub ids: &'a mut IdMap,
+    /// Whether to allow the use of explicit error codes in doctest lang strings.
+    pub error_codes: ErrorCodes,
+    /// Default edition to use when parsing doctests (to add a `fn main`).
+    pub edition: Edition,
+    pub playground: &'a Option<Playground>,
+    /// Offset at which we render headings.
+    /// E.g. if `heading_offset: HeadingOffset::H2`, then `# something` renders an `<h2>`.
+    pub heading_offset: HeadingOffset,
+}
+/// A tuple struct like `Markdown` that renders the markdown with a table of contents.
+pub(crate) struct MarkdownWithToc<'a>(
+    pub(crate) &'a str,
+    pub(crate) &'a mut IdMap,
+    pub(crate) ErrorCodes,
+    pub(crate) Edition,
+    pub(crate) &'a Option<Playground>,
+);
+/// A tuple struct like `Markdown` that renders the markdown escaping HTML tags.
+pub(crate) struct MarkdownHtml<'a>(
+    pub(crate) &'a str,
+    pub(crate) &'a mut IdMap,
+    pub(crate) ErrorCodes,
+    pub(crate) Edition,
+    pub(crate) &'a Option<Playground>,
+);
+/// A tuple struct like `Markdown` that renders only the first paragraph.
+pub(crate) struct MarkdownSummaryLine<'a>(pub &'a str, pub &'a [RenderedLink]);
+
+#[derive(Copy, Clone, PartialEq, Debug)]
+pub enum ErrorCodes {
+    Yes,
+    No,
+}
+
+impl ErrorCodes {
+    pub(crate) fn from(b: bool) -> Self {
+        match b {
+            true => ErrorCodes::Yes,
+            false => ErrorCodes::No,
+        }
+    }
+
+    pub(crate) fn as_bool(self) -> bool {
+        match self {
+            ErrorCodes::Yes => true,
+            ErrorCodes::No => false,
+        }
+    }
+}
+
+/// Controls whether a line will be hidden or shown in HTML output.
+///
+/// All lines are used in documentation tests.
+enum Line<'a> {
+    Hidden(&'a str),
+    Shown(Cow<'a, str>),
+}
+
+impl<'a> Line<'a> {
+    fn for_html(self) -> Option<Cow<'a, str>> {
+        match self {
+            Line::Shown(l) => Some(l),
+            Line::Hidden(_) => None,
+        }
+    }
+
+    fn for_code(self) -> Cow<'a, str> {
+        match self {
+            Line::Shown(l) => l,
+            Line::Hidden(l) => Cow::Borrowed(l),
+        }
+    }
+}
+
+// FIXME: There is a minor inconsistency here. For lines that start with ##, we
+// have no easy way of removing a potential single space after the hashes, which
+// is done in the single # case. This inconsistency seems okay, if non-ideal. In
+// order to fix it we'd have to iterate to find the first non-# character, and
+// then reallocate to remove it; which would make us return a String.
+fn map_line(s: &str) -> Line<'_> {
+    let trimmed = s.trim();
+    if trimmed.starts_with("##") {
+        Line::Shown(Cow::Owned(s.replacen("##", "#", 1)))
+    } else if let Some(stripped) = trimmed.strip_prefix("# ") {
+        // # text
+        Line::Hidden(stripped)
+    } else if trimmed == "#" {
+        // We cannot handle '#text' because it could be #[attr].
+        Line::Hidden("")
+    } else {
+        Line::Shown(Cow::Borrowed(s))
+    }
+}
+
+/// Convert chars from a title for an id.
+///
+/// "Hello, world!" -> "hello-world"
+fn slugify(c: char) -> Option<char> {
+    if c.is_alphanumeric() || c == '-' || c == '_' {
+        if c.is_ascii() { Some(c.to_ascii_lowercase()) } else { Some(c) }
+    } else if c.is_whitespace() && c.is_ascii() {
+        Some('-')
+    } else {
+        None
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct Playground {
+    pub crate_name: Option<String>,
+    pub url: String,
+}
+
+/// Adds syntax highlighting and playground Run buttons to Rust code blocks.
+struct CodeBlocks<'p, 'a, I: Iterator<Item = Event<'a>>> {
+    inner: I,
+    check_error_codes: ErrorCodes,
+    edition: Edition,
+    // Information about the playground if a URL has been specified, containing an
+    // optional crate name and the URL.
+    playground: &'p Option<Playground>,
+}
+
+impl<'p, 'a, I: Iterator<Item = Event<'a>>> CodeBlocks<'p, 'a, I> {
+    fn new(
+        iter: I,
+        error_codes: ErrorCodes,
+        edition: Edition,
+        playground: &'p Option<Playground>,
+    ) -> Self {
+        CodeBlocks { inner: iter, check_error_codes: error_codes, edition, playground }
+    }
+}
+
+impl<'a, I: Iterator<Item = Event<'a>>> Iterator for CodeBlocks<'_, 'a, I> {
+    type Item = Event<'a>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let event = self.inner.next();
+        let compile_fail;
+        let should_panic;
+        let ignore;
+        let edition;
+        let Some(Event::Start(Tag::CodeBlock(kind))) = event else {
+            return event;
+        };
+
+        let mut origtext = String::new();
+        for event in &mut self.inner {
+            match event {
+                Event::End(Tag::CodeBlock(..)) => break,
+                Event::Text(ref s) => {
+                    origtext.push_str(s);
+                }
+                _ => {}
+            }
+        }
+        let lines = origtext.lines().filter_map(|l| map_line(l).for_html());
+        let text = lines.intersperse("\n".into()).collect::<String>();
+
+        let parse_result = match kind {
+            CodeBlockKind::Fenced(ref lang) => {
+                let parse_result =
+                    LangString::parse_without_check(lang, self.check_error_codes, false);
+                if !parse_result.rust {
+                    return Some(Event::Html(
+                        format!(
+                            "<div class=\"example-wrap\">\
+                                 <pre class=\"language-{}\"><code>{}</code></pre>\
+                             </div>",
+                            lang,
+                            Escape(&text),
+                        )
+                        .into(),
+                    ));
+                }
+                parse_result
+            }
+            CodeBlockKind::Indented => Default::default(),
+        };
+
+        compile_fail = parse_result.compile_fail;
+        should_panic = parse_result.should_panic;
+        ignore = parse_result.ignore;
+        edition = parse_result.edition;
+
+        let explicit_edition = edition.is_some();
+        let edition = edition.unwrap_or(self.edition);
+
+        let playground_button = self.playground.as_ref().and_then(|playground| {
+            let krate = &playground.crate_name;
+            let url = &playground.url;
+            if url.is_empty() {
+                return None;
+            }
+            let test = origtext
+                .lines()
+                .map(|l| map_line(l).for_code())
+                .intersperse("\n".into())
+                .collect::<String>();
+            let krate = krate.as_ref().map(|s| &**s);
+            let (test, _, _) =
+                doctest::make_test(&test, krate, false, &Default::default(), edition, None);
+            let channel = if test.contains("#![feature(") { "&amp;version=nightly" } else { "" };
+
+            // These characters don't need to be escaped in a URI.
+            // FIXME: use a library function for percent encoding.
+            fn dont_escape(c: u8) -> bool {
+                (b'a' <= c && c <= b'z')
+                    || (b'A' <= c && c <= b'Z')
+                    || (b'0' <= c && c <= b'9')
+                    || c == b'-'
+                    || c == b'_'
+                    || c == b'.'
+                    || c == b'~'
+                    || c == b'!'
+                    || c == b'\''
+                    || c == b'('
+                    || c == b')'
+                    || c == b'*'
+            }
+            let mut test_escaped = String::new();
+            for b in test.bytes() {
+                if dont_escape(b) {
+                    test_escaped.push(char::from(b));
+                } else {
+                    write!(test_escaped, "%{:02X}", b).unwrap();
+                }
+            }
+            Some(format!(
+                r#"<a class="test-arrow" target="_blank" href="{}?code={}{}&amp;edition={}">Run</a>"#,
+                url, test_escaped, channel, edition,
+            ))
+        });
+
+        let tooltip = if ignore != Ignore::None {
+            Some((None, "ignore"))
+        } else if compile_fail {
+            Some((None, "compile_fail"))
+        } else if should_panic {
+            Some((None, "should_panic"))
+        } else if explicit_edition {
+            Some((Some(edition), "edition"))
+        } else {
+            None
+        };
+
+        // insert newline to clearly separate it from the
+        // previous block so we can shorten the html output
+        let mut s = Buffer::new();
+        s.push_str("\n");
+        highlight::render_with_highlighting(
+            &text,
+            &mut s,
+            Some(&format!(
+                "rust-example-rendered{}",
+                if let Some((_, class)) = tooltip { format!(" {}", class) } else { String::new() }
+            )),
+            playground_button.as_deref(),
+            tooltip,
+            edition,
+            None,
+            None,
+            None,
+        );
+        Some(Event::Html(s.into_inner().into()))
+    }
+}
+
+/// Make headings links with anchor IDs and build up TOC.
+struct LinkReplacer<'a, I: Iterator<Item = Event<'a>>> {
+    inner: I,
+    links: &'a [RenderedLink],
+    shortcut_link: Option<&'a RenderedLink>,
+}
+
+impl<'a, I: Iterator<Item = Event<'a>>> LinkReplacer<'a, I> {
+    fn new(iter: I, links: &'a [RenderedLink]) -> Self {
+        LinkReplacer { inner: iter, links, shortcut_link: None }
+    }
+}
+
+impl<'a, I: Iterator<Item = Event<'a>>> Iterator for LinkReplacer<'a, I> {
+    type Item = Event<'a>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let mut event = self.inner.next();
+
+        // Replace intra-doc links and remove disambiguators from shortcut links (`[fn@f]`).
+        match &mut event {
+            // This is a shortcut link that was resolved by the broken_link_callback: `[fn@f]`
+            // Remove any disambiguator.
+            Some(Event::Start(Tag::Link(
+                // [fn@f] or [fn@f][]
+                LinkType::ShortcutUnknown | LinkType::CollapsedUnknown,
+                dest,
+                title,
+            ))) => {
+                debug!("saw start of shortcut link to {} with title {}", dest, title);
+                // If this is a shortcut link, it was resolved by the broken_link_callback.
+                // So the URL will already be updated properly.
+                let link = self.links.iter().find(|&link| *link.href == **dest);
+                // Since this is an external iterator, we can't replace the inner text just yet.
+                // Store that we saw a link so we know to replace it later.
+                if let Some(link) = link {
+                    trace!("it matched");
+                    assert!(self.shortcut_link.is_none(), "shortcut links cannot be nested");
+                    self.shortcut_link = Some(link);
+                }
+            }
+            // Now that we're done with the shortcut link, don't replace any more text.
+            Some(Event::End(Tag::Link(
+                LinkType::ShortcutUnknown | LinkType::CollapsedUnknown,
+                dest,
+                _,
+            ))) => {
+                debug!("saw end of shortcut link to {}", dest);
+                if self.links.iter().any(|link| *link.href == **dest) {
+                    assert!(self.shortcut_link.is_some(), "saw closing link without opening tag");
+                    self.shortcut_link = None;
+                }
+            }
+            // Handle backticks in inline code blocks, but only if we're in the middle of a shortcut link.
+            // [`fn@f`]
+            Some(Event::Code(text)) => {
+                trace!("saw code {}", text);
+                if let Some(link) = self.shortcut_link {
+                    trace!("original text was {}", link.original_text);
+                    // NOTE: this only replaces if the code block is the *entire* text.
+                    // If only part of the link has code highlighting, the disambiguator will not be removed.
+                    // e.g. [fn@`f`]
+                    // This is a limitation from `collect_intra_doc_links`: it passes a full link,
+                    // and does not distinguish at all between code blocks.
+                    // So we could never be sure we weren't replacing too much:
+                    // [fn@my_`f`unc] is treated the same as [my_func()] in that pass.
+                    //
+                    // NOTE: &[1..len() - 1] is to strip the backticks
+                    if **text == link.original_text[1..link.original_text.len() - 1] {
+                        debug!("replacing {} with {}", text, link.new_text);
+                        *text = CowStr::Borrowed(&link.new_text);
+                    }
+                }
+            }
+            // Replace plain text in links, but only in the middle of a shortcut link.
+            // [fn@f]
+            Some(Event::Text(text)) => {
+                trace!("saw text {}", text);
+                if let Some(link) = self.shortcut_link {
+                    trace!("original text was {}", link.original_text);
+                    // NOTE: same limitations as `Event::Code`
+                    if **text == *link.original_text {
+                        debug!("replacing {} with {}", text, link.new_text);
+                        *text = CowStr::Borrowed(&link.new_text);
+                    }
+                }
+            }
+            // If this is a link, but not a shortcut link,
+            // replace the URL, since the broken_link_callback was not called.
+            Some(Event::Start(Tag::Link(_, dest, _))) => {
+                if let Some(link) = self.links.iter().find(|&link| *link.original_text == **dest) {
+                    *dest = CowStr::Borrowed(link.href.as_ref());
+                }
+            }
+            // Anything else couldn't have been a valid Rust path, so no need to replace the text.
+            _ => {}
+        }
+
+        // Yield the modified event
+        event
+    }
+}
+
+/// Wrap HTML tables into `<div>` to prevent having the doc blocks width being too big.
+struct TableWrapper<'a, I: Iterator<Item = Event<'a>>> {
+    inner: I,
+    stored_events: VecDeque<Event<'a>>,
+}
+
+impl<'a, I: Iterator<Item = Event<'a>>> TableWrapper<'a, I> {
+    fn new(iter: I) -> Self {
+        Self { inner: iter, stored_events: VecDeque::new() }
+    }
+}
+
+impl<'a, I: Iterator<Item = Event<'a>>> Iterator for TableWrapper<'a, I> {
+    type Item = Event<'a>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if let Some(first) = self.stored_events.pop_front() {
+            return Some(first);
+        }
+
+        let event = self.inner.next()?;
+
+        Some(match event {
+            Event::Start(Tag::Table(t)) => {
+                self.stored_events.push_back(Event::Start(Tag::Table(t)));
+                Event::Html(CowStr::Borrowed("<div>"))
+            }
+            Event::End(Tag::Table(t)) => {
+                self.stored_events.push_back(Event::Html(CowStr::Borrowed("</div>")));
+                Event::End(Tag::Table(t))
+            }
+            e => e,
+        })
+    }
+}
+
+type SpannedEvent<'a> = (Event<'a>, Range<usize>);
+
+/// Make headings links with anchor IDs and build up TOC.
+struct HeadingLinks<'a, 'b, 'ids, I> {
+    inner: I,
+    toc: Option<&'b mut TocBuilder>,
+    buf: VecDeque<SpannedEvent<'a>>,
+    id_map: &'ids mut IdMap,
+    heading_offset: HeadingOffset,
+}
+
+impl<'a, 'b, 'ids, I> HeadingLinks<'a, 'b, 'ids, I> {
+    fn new(
+        iter: I,
+        toc: Option<&'b mut TocBuilder>,
+        ids: &'ids mut IdMap,
+        heading_offset: HeadingOffset,
+    ) -> Self {
+        HeadingLinks { inner: iter, toc, buf: VecDeque::new(), id_map: ids, heading_offset }
+    }
+}
+
+impl<'a, 'b, 'ids, I: Iterator<Item = SpannedEvent<'a>>> Iterator
+    for HeadingLinks<'a, 'b, 'ids, I>
+{
+    type Item = SpannedEvent<'a>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if let Some(e) = self.buf.pop_front() {
+            return Some(e);
+        }
+
+        let event = self.inner.next();
+        if let Some((Event::Start(Tag::Heading(level, _, _)), _)) = event {
+            let mut id = String::new();
+            for event in &mut self.inner {
+                match &event.0 {
+                    Event::End(Tag::Heading(..)) => break,
+                    Event::Start(Tag::Link(_, _, _)) | Event::End(Tag::Link(..)) => {}
+                    Event::Text(text) | Event::Code(text) => {
+                        id.extend(text.chars().filter_map(slugify));
+                        self.buf.push_back(event);
+                    }
+                    _ => self.buf.push_back(event),
+                }
+            }
+            let id = self.id_map.derive(id);
+
+            if let Some(ref mut builder) = self.toc {
+                let mut html_header = String::new();
+                html::push_html(&mut html_header, self.buf.iter().map(|(ev, _)| ev.clone()));
+                let sec = builder.push(level as u32, html_header, id.clone());
+                self.buf.push_front((Event::Html(format!("{} ", sec).into()), 0..0));
+            }
+
+            let level =
+                std::cmp::min(level as u32 + (self.heading_offset as u32), MAX_HEADER_LEVEL);
+            self.buf.push_back((Event::Html(format!("</a></h{}>", level).into()), 0..0));
+
+            let start_tags = format!(
+                "<h{level} id=\"{id}\">\
+                    <a href=\"#{id}\">",
+                id = id,
+                level = level
+            );
+            return Some((Event::Html(start_tags.into()), 0..0));
+        }
+        event
+    }
+}
+
+/// Extracts just the first paragraph.
+struct SummaryLine<'a, I: Iterator<Item = Event<'a>>> {
+    inner: I,
+    started: bool,
+    depth: u32,
+}
+
+impl<'a, I: Iterator<Item = Event<'a>>> SummaryLine<'a, I> {
+    fn new(iter: I) -> Self {
+        SummaryLine { inner: iter, started: false, depth: 0 }
+    }
+}
+
+fn check_if_allowed_tag(t: &Tag<'_>) -> bool {
+    matches!(
+        t,
+        Tag::Paragraph | Tag::Item | Tag::Emphasis | Tag::Strong | Tag::Link(..) | Tag::BlockQuote
+    )
+}
+
+fn is_forbidden_tag(t: &Tag<'_>) -> bool {
+    matches!(t, Tag::CodeBlock(_) | Tag::Table(_) | Tag::TableHead | Tag::TableRow | Tag::TableCell)
+}
+
+impl<'a, I: Iterator<Item = Event<'a>>> Iterator for SummaryLine<'a, I> {
+    type Item = Event<'a>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.started && self.depth == 0 {
+            return None;
+        }
+        if !self.started {
+            self.started = true;
+        }
+        if let Some(event) = self.inner.next() {
+            let mut is_start = true;
+            let is_allowed_tag = match event {
+                Event::Start(ref c) => {
+                    if is_forbidden_tag(c) {
+                        return None;
+                    }
+                    self.depth += 1;
+                    check_if_allowed_tag(c)
+                }
+                Event::End(ref c) => {
+                    if is_forbidden_tag(c) {
+                        return None;
+                    }
+                    self.depth -= 1;
+                    is_start = false;
+                    check_if_allowed_tag(c)
+                }
+                _ => true,
+            };
+            return if !is_allowed_tag {
+                if is_start {
+                    Some(Event::Start(Tag::Paragraph))
+                } else {
+                    Some(Event::End(Tag::Paragraph))
+                }
+            } else {
+                Some(event)
+            };
+        }
+        None
+    }
+}
+
+/// Moves all footnote definitions to the end and add back links to the
+/// references.
+struct Footnotes<'a, I> {
+    inner: I,
+    footnotes: FxHashMap<String, (Vec<Event<'a>>, u16)>,
+}
+
+impl<'a, I> Footnotes<'a, I> {
+    fn new(iter: I) -> Self {
+        Footnotes { inner: iter, footnotes: FxHashMap::default() }
+    }
+
+    fn get_entry(&mut self, key: &str) -> &mut (Vec<Event<'a>>, u16) {
+        let new_id = self.footnotes.len() + 1;
+        let key = key.to_owned();
+        self.footnotes.entry(key).or_insert((Vec::new(), new_id as u16))
+    }
+}
+
+impl<'a, I: Iterator<Item = SpannedEvent<'a>>> Iterator for Footnotes<'a, I> {
+    type Item = SpannedEvent<'a>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        loop {
+            match self.inner.next() {
+                Some((Event::FootnoteReference(ref reference), range)) => {
+                    let entry = self.get_entry(reference);
+                    let reference = format!(
+                        "<sup id=\"fnref{0}\"><a href=\"#fn{0}\">{0}</a></sup>",
+                        (*entry).1
+                    );
+                    return Some((Event::Html(reference.into()), range));
+                }
+                Some((Event::Start(Tag::FootnoteDefinition(def)), _)) => {
+                    let mut content = Vec::new();
+                    for (event, _) in &mut self.inner {
+                        if let Event::End(Tag::FootnoteDefinition(..)) = event {
+                            break;
+                        }
+                        content.push(event);
+                    }
+                    let entry = self.get_entry(&def);
+                    (*entry).0 = content;
+                }
+                Some(e) => return Some(e),
+                None => {
+                    if !self.footnotes.is_empty() {
+                        let mut v: Vec<_> = self.footnotes.drain().map(|(_, x)| x).collect();
+                        v.sort_by(|a, b| a.1.cmp(&b.1));
+                        let mut ret = String::from("<div class=\"footnotes\"><hr><ol>");
+                        for (mut content, id) in v {
+                            write!(ret, "<li id=\"fn{}\">", id).unwrap();
+                            let mut is_paragraph = false;
+                            if let Some(&Event::End(Tag::Paragraph)) = content.last() {
+                                content.pop();
+                                is_paragraph = true;
+                            }
+                            html::push_html(&mut ret, content.into_iter());
+                            write!(ret, "&nbsp;<a href=\"#fnref{}\">↩</a>", id).unwrap();
+                            if is_paragraph {
+                                ret.push_str("</p>");
+                            }
+                            ret.push_str("</li>");
+                        }
+                        ret.push_str("</ol></div>");
+                        return Some((Event::Html(ret.into()), 0..0));
+                    } else {
+                        return None;
+                    }
+                }
+            }
+        }
+    }
+}
+
+pub(crate) fn find_testable_code<T: doctest::Tester>(
+    doc: &str,
+    tests: &mut T,
+    error_codes: ErrorCodes,
+    enable_per_target_ignores: bool,
+    extra_info: Option<&ExtraInfo<'_>>,
+) {
+    let mut parser = Parser::new(doc).into_offset_iter();
+    let mut prev_offset = 0;
+    let mut nb_lines = 0;
+    let mut register_header = None;
+    while let Some((event, offset)) = parser.next() {
+        match event {
+            Event::Start(Tag::CodeBlock(kind)) => {
+                let block_info = match kind {
+                    CodeBlockKind::Fenced(ref lang) => {
+                        if lang.is_empty() {
+                            Default::default()
+                        } else {
+                            LangString::parse(
+                                lang,
+                                error_codes,
+                                enable_per_target_ignores,
+                                extra_info,
+                            )
+                        }
+                    }
+                    CodeBlockKind::Indented => Default::default(),
+                };
+                if !block_info.rust {
+                    continue;
+                }
+
+                let mut test_s = String::new();
+
+                while let Some((Event::Text(s), _)) = parser.next() {
+                    test_s.push_str(&s);
+                }
+                let text = test_s
+                    .lines()
+                    .map(|l| map_line(l).for_code())
+                    .collect::<Vec<Cow<'_, str>>>()
+                    .join("\n");
+
+                nb_lines += doc[prev_offset..offset.start].lines().count();
+                // If there are characters between the preceding line ending and
+                // this code block, `str::lines` will return an additional line,
+                // which we subtract here.
+                if nb_lines != 0 && !&doc[prev_offset..offset.start].ends_with('\n') {
+                    nb_lines -= 1;
+                }
+                let line = tests.get_line() + nb_lines + 1;
+                tests.add_test(text, block_info, line);
+                prev_offset = offset.start;
+            }
+            Event::Start(Tag::Heading(level, _, _)) => {
+                register_header = Some(level as u32);
+            }
+            Event::Text(ref s) if register_header.is_some() => {
+                let level = register_header.unwrap();
+                if s.is_empty() {
+                    tests.register_header("", level);
+                } else {
+                    tests.register_header(s, level);
+                }
+                register_header = None;
+            }
+            _ => {}
+        }
+    }
+}
+
+pub(crate) struct ExtraInfo<'tcx> {
+    id: ExtraInfoId,
+    sp: Span,
+    tcx: TyCtxt<'tcx>,
+}
+
+enum ExtraInfoId {
+    Hir(HirId),
+    Def(DefId),
+}
+
+impl<'tcx> ExtraInfo<'tcx> {
+    pub(crate) fn new(tcx: TyCtxt<'tcx>, hir_id: HirId, sp: Span) -> ExtraInfo<'tcx> {
+        ExtraInfo { id: ExtraInfoId::Hir(hir_id), sp, tcx }
+    }
+
+    pub(crate) fn new_did(tcx: TyCtxt<'tcx>, did: DefId, sp: Span) -> ExtraInfo<'tcx> {
+        ExtraInfo { id: ExtraInfoId::Def(did), sp, tcx }
+    }
+
+    fn error_invalid_codeblock_attr(&self, msg: &str, help: &str) {
+        let hir_id = match self.id {
+            ExtraInfoId::Hir(hir_id) => hir_id,
+            ExtraInfoId::Def(item_did) => {
+                match item_did.as_local() {
+                    Some(item_did) => self.tcx.hir().local_def_id_to_hir_id(item_did),
+                    None => {
+                        // If non-local, no need to check anything.
+                        return;
+                    }
+                }
+            }
+        };
+        self.tcx.struct_span_lint_hir(
+            crate::lint::INVALID_CODEBLOCK_ATTRIBUTES,
+            hir_id,
+            self.sp,
+            |lint| {
+                let mut diag = lint.build(msg);
+                diag.help(help);
+                diag.emit();
+            },
+        );
+    }
+}
+
+#[derive(Eq, PartialEq, Clone, Debug)]
+pub(crate) struct LangString {
+    original: String,
+    pub(crate) should_panic: bool,
+    pub(crate) no_run: bool,
+    pub(crate) ignore: Ignore,
+    pub(crate) rust: bool,
+    pub(crate) test_harness: bool,
+    pub(crate) compile_fail: bool,
+    pub(crate) error_codes: Vec<String>,
+    pub(crate) edition: Option<Edition>,
+}
+
+#[derive(Eq, PartialEq, Clone, Debug)]
+pub(crate) enum Ignore {
+    All,
+    None,
+    Some(Vec<String>),
+}
+
+impl Default for LangString {
+    fn default() -> Self {
+        Self {
+            original: String::new(),
+            should_panic: false,
+            no_run: false,
+            ignore: Ignore::None,
+            rust: true,
+            test_harness: false,
+            compile_fail: false,
+            error_codes: Vec::new(),
+            edition: None,
+        }
+    }
+}
+
+impl LangString {
+    fn parse_without_check(
+        string: &str,
+        allow_error_code_check: ErrorCodes,
+        enable_per_target_ignores: bool,
+    ) -> LangString {
+        Self::parse(string, allow_error_code_check, enable_per_target_ignores, None)
+    }
+
+    fn tokens(string: &str) -> impl Iterator<Item = &str> {
+        // Pandoc, which Rust once used for generating documentation,
+        // expects lang strings to be surrounded by `{}` and for each token
+        // to be proceeded by a `.`. Since some of these lang strings are still
+        // loose in the wild, we strip a pair of surrounding `{}` from the lang
+        // string and a leading `.` from each token.
+
+        let string = string.trim();
+
+        let first = string.chars().next();
+        let last = string.chars().last();
+
+        let string = if first == Some('{') && last == Some('}') {
+            &string[1..string.len() - 1]
+        } else {
+            string
+        };
+
+        string
+            .split(|c| c == ',' || c == ' ' || c == '\t')
+            .map(str::trim)
+            .map(|token| token.strip_prefix('.').unwrap_or(token))
+            .filter(|token| !token.is_empty())
+    }
+
+    fn parse(
+        string: &str,
+        allow_error_code_check: ErrorCodes,
+        enable_per_target_ignores: bool,
+        extra: Option<&ExtraInfo<'_>>,
+    ) -> LangString {
+        let allow_error_code_check = allow_error_code_check.as_bool();
+        let mut seen_rust_tags = false;
+        let mut seen_other_tags = false;
+        let mut data = LangString::default();
+        let mut ignores = vec![];
+
+        data.original = string.to_owned();
+
+        for token in Self::tokens(string) {
+            match token {
+                "should_panic" => {
+                    data.should_panic = true;
+                    seen_rust_tags = !seen_other_tags;
+                }
+                "no_run" => {
+                    data.no_run = true;
+                    seen_rust_tags = !seen_other_tags;
+                }
+                "ignore" => {
+                    data.ignore = Ignore::All;
+                    seen_rust_tags = !seen_other_tags;
+                }
+                x if x.starts_with("ignore-") => {
+                    if enable_per_target_ignores {
+                        ignores.push(x.trim_start_matches("ignore-").to_owned());
+                        seen_rust_tags = !seen_other_tags;
+                    }
+                }
+                "rust" => {
+                    data.rust = true;
+                    seen_rust_tags = true;
+                }
+                "test_harness" => {
+                    data.test_harness = true;
+                    seen_rust_tags = !seen_other_tags || seen_rust_tags;
+                }
+                "compile_fail" => {
+                    data.compile_fail = true;
+                    seen_rust_tags = !seen_other_tags || seen_rust_tags;
+                    data.no_run = true;
+                }
+                x if x.starts_with("edition") => {
+                    data.edition = x[7..].parse::<Edition>().ok();
+                }
+                x if allow_error_code_check && x.starts_with('E') && x.len() == 5 => {
+                    if x[1..].parse::<u32>().is_ok() {
+                        data.error_codes.push(x.to_owned());
+                        seen_rust_tags = !seen_other_tags || seen_rust_tags;
+                    } else {
+                        seen_other_tags = true;
+                    }
+                }
+                x if extra.is_some() => {
+                    let s = x.to_lowercase();
+                    if let Some((flag, help)) = if s == "compile-fail"
+                        || s == "compile_fail"
+                        || s == "compilefail"
+                    {
+                        Some((
+                            "compile_fail",
+                            "the code block will either not be tested if not marked as a rust one \
+                             or won't fail if it compiles successfully",
+                        ))
+                    } else if s == "should-panic" || s == "should_panic" || s == "shouldpanic" {
+                        Some((
+                            "should_panic",
+                            "the code block will either not be tested if not marked as a rust one \
+                             or won't fail if it doesn't panic when running",
+                        ))
+                    } else if s == "no-run" || s == "no_run" || s == "norun" {
+                        Some((
+                            "no_run",
+                            "the code block will either not be tested if not marked as a rust one \
+                             or will be run (which you might not want)",
+                        ))
+                    } else if s == "test-harness" || s == "test_harness" || s == "testharness" {
+                        Some((
+                            "test_harness",
+                            "the code block will either not be tested if not marked as a rust one \
+                             or the code will be wrapped inside a main function",
+                        ))
+                    } else {
+                        None
+                    } {
+                        if let Some(extra) = extra {
+                            extra.error_invalid_codeblock_attr(
+                                &format!("unknown attribute `{}`. Did you mean `{}`?", x, flag),
+                                help,
+                            );
+                        }
+                    }
+                    seen_other_tags = true;
+                }
+                _ => seen_other_tags = true,
+            }
+        }
+
+        // ignore-foo overrides ignore
+        if !ignores.is_empty() {
+            data.ignore = Ignore::Some(ignores);
+        }
+
+        data.rust &= !seen_other_tags || seen_rust_tags;
+
+        data
+    }
+}
+
+impl Markdown<'_> {
+    pub fn into_string(self) -> String {
+        let Markdown {
+            content: md,
+            links,
+            ids,
+            error_codes: codes,
+            edition,
+            playground,
+            heading_offset,
+        } = self;
+
+        // This is actually common enough to special-case
+        if md.is_empty() {
+            return String::new();
+        }
+        let mut replacer = |broken_link: BrokenLink<'_>| {
+            links
+                .iter()
+                .find(|link| link.original_text.as_str() == &*broken_link.reference)
+                .map(|link| (link.href.as_str().into(), link.new_text.as_str().into()))
+        };
+
+        let p = Parser::new_with_broken_link_callback(md, main_body_opts(), Some(&mut replacer));
+        let p = p.into_offset_iter();
+
+        let mut s = String::with_capacity(md.len() * 3 / 2);
+
+        let p = HeadingLinks::new(p, None, ids, heading_offset);
+        let p = Footnotes::new(p);
+        let p = LinkReplacer::new(p.map(|(ev, _)| ev), links);
+        let p = TableWrapper::new(p);
+        let p = CodeBlocks::new(p, codes, edition, playground);
+        html::push_html(&mut s, p);
+
+        s
+    }
+}
+
+impl MarkdownWithToc<'_> {
+    pub(crate) fn into_string(self) -> String {
+        let MarkdownWithToc(md, ids, codes, edition, playground) = self;
+
+        let p = Parser::new_ext(md, main_body_opts()).into_offset_iter();
+
+        let mut s = String::with_capacity(md.len() * 3 / 2);
+
+        let mut toc = TocBuilder::new();
+
+        {
+            let p = HeadingLinks::new(p, Some(&mut toc), ids, HeadingOffset::H1);
+            let p = Footnotes::new(p);
+            let p = TableWrapper::new(p.map(|(ev, _)| ev));
+            let p = CodeBlocks::new(p, codes, edition, playground);
+            html::push_html(&mut s, p);
+        }
+
+        format!("<nav id=\"TOC\">{}</nav>{}", toc.into_toc().print(), s)
+    }
+}
+
+impl MarkdownHtml<'_> {
+    pub(crate) fn into_string(self) -> String {
+        let MarkdownHtml(md, ids, codes, edition, playground) = self;
+
+        // This is actually common enough to special-case
+        if md.is_empty() {
+            return String::new();
+        }
+        let p = Parser::new_ext(md, main_body_opts()).into_offset_iter();
+
+        // Treat inline HTML as plain text.
+        let p = p.map(|event| match event.0 {
+            Event::Html(text) => (Event::Text(text), event.1),
+            _ => event,
+        });
+
+        let mut s = String::with_capacity(md.len() * 3 / 2);
+
+        let p = HeadingLinks::new(p, None, ids, HeadingOffset::H1);
+        let p = Footnotes::new(p);
+        let p = TableWrapper::new(p.map(|(ev, _)| ev));
+        let p = CodeBlocks::new(p, codes, edition, playground);
+        html::push_html(&mut s, p);
+
+        s
+    }
+}
+
+impl MarkdownSummaryLine<'_> {
+    pub(crate) fn into_string(self) -> String {
+        let MarkdownSummaryLine(md, links) = self;
+        // This is actually common enough to special-case
+        if md.is_empty() {
+            return String::new();
+        }
+
+        let mut replacer = |broken_link: BrokenLink<'_>| {
+            links
+                .iter()
+                .find(|link| link.original_text.as_str() == &*broken_link.reference)
+                .map(|link| (link.href.as_str().into(), link.new_text.as_str().into()))
+        };
+
+        let p = Parser::new_with_broken_link_callback(md, summary_opts(), Some(&mut replacer));
+
+        let mut s = String::new();
+
+        html::push_html(&mut s, LinkReplacer::new(SummaryLine::new(p), links));
+
+        s
+    }
+}
+
+/// Renders a subset of Markdown in the first paragraph of the provided Markdown.
+///
+/// - *Italics*, **bold**, and `inline code` styles **are** rendered.
+/// - Headings and links are stripped (though the text *is* rendered).
+/// - HTML, code blocks, and everything else are ignored.
+///
+/// Returns a tuple of the rendered HTML string and whether the output was shortened
+/// due to the provided `length_limit`.
+fn markdown_summary_with_limit(
+    md: &str,
+    link_names: &[RenderedLink],
+    length_limit: usize,
+) -> (String, bool) {
+    if md.is_empty() {
+        return (String::new(), false);
+    }
+
+    let mut replacer = |broken_link: BrokenLink<'_>| {
+        link_names
+            .iter()
+            .find(|link| link.original_text.as_str() == &*broken_link.reference)
+            .map(|link| (link.href.as_str().into(), link.new_text.as_str().into()))
+    };
+
+    let p = Parser::new_with_broken_link_callback(md, summary_opts(), Some(&mut replacer));
+    let mut p = LinkReplacer::new(p, link_names);
+
+    let mut buf = HtmlWithLimit::new(length_limit);
+    let mut stopped_early = false;
+    p.try_for_each(|event| {
+        match &event {
+            Event::Text(text) => {
+                let r =
+                    text.split_inclusive(char::is_whitespace).try_for_each(|word| buf.push(word));
+                if r.is_break() {
+                    stopped_early = true;
+                }
+                return r;
+            }
+            Event::Code(code) => {
+                buf.open_tag("code");
+                let r = buf.push(code);
+                if r.is_break() {
+                    stopped_early = true;
+                } else {
+                    buf.close_tag();
+                }
+                return r;
+            }
+            Event::Start(tag) => match tag {
+                Tag::Emphasis => buf.open_tag("em"),
+                Tag::Strong => buf.open_tag("strong"),
+                Tag::CodeBlock(..) => return ControlFlow::BREAK,
+                _ => {}
+            },
+            Event::End(tag) => match tag {
+                Tag::Emphasis | Tag::Strong => buf.close_tag(),
+                Tag::Paragraph | Tag::Heading(..) => return ControlFlow::BREAK,
+                _ => {}
+            },
+            Event::HardBreak | Event::SoftBreak => buf.push(" ")?,
+            _ => {}
+        };
+        ControlFlow::CONTINUE
+    });
+
+    (buf.finish(), stopped_early)
+}
+
+/// Renders a shortened first paragraph of the given Markdown as a subset of Markdown,
+/// making it suitable for contexts like the search index.
+///
+/// Will shorten to 59 or 60 characters, including an ellipsis (…) if it was shortened.
+///
+/// See [`markdown_summary_with_limit`] for details about what is rendered and what is not.
+pub(crate) fn short_markdown_summary(markdown: &str, link_names: &[RenderedLink]) -> String {
+    let (mut s, was_shortened) = markdown_summary_with_limit(markdown, link_names, 59);
+
+    if was_shortened {
+        s.push('…');
+    }
+
+    s
+}
+
+/// Renders the first paragraph of the provided markdown as plain text.
+/// Useful for alt-text.
+///
+/// - Headings, links, and formatting are stripped.
+/// - Inline code is rendered as-is, surrounded by backticks.
+/// - HTML and code blocks are ignored.
+pub(crate) fn plain_text_summary(md: &str) -> String {
+    if md.is_empty() {
+        return String::new();
+    }
+
+    let mut s = String::with_capacity(md.len() * 3 / 2);
+
+    for event in Parser::new_ext(md, summary_opts()) {
+        match &event {
+            Event::Text(text) => s.push_str(text),
+            Event::Code(code) => {
+                s.push('`');
+                s.push_str(code);
+                s.push('`');
+            }
+            Event::HardBreak | Event::SoftBreak => s.push(' '),
+            Event::Start(Tag::CodeBlock(..)) => break,
+            Event::End(Tag::Paragraph) => break,
+            Event::End(Tag::Heading(..)) => break,
+            _ => (),
+        }
+    }
+
+    s
+}
+
+#[derive(Debug)]
+pub(crate) struct MarkdownLink {
+    pub kind: LinkType,
+    pub link: String,
+    pub range: Range<usize>,
+}
+
+pub(crate) fn markdown_links<R>(
+    md: &str,
+    filter_map: impl Fn(MarkdownLink) -> Option<R>,
+) -> Vec<R> {
+    if md.is_empty() {
+        return vec![];
+    }
+
+    let links = RefCell::new(vec![]);
+
+    // FIXME: remove this function once pulldown_cmark can provide spans for link definitions.
+    let locate = |s: &str, fallback: Range<usize>| unsafe {
+        let s_start = s.as_ptr();
+        let s_end = s_start.add(s.len());
+        let md_start = md.as_ptr();
+        let md_end = md_start.add(md.len());
+        if md_start <= s_start && s_end <= md_end {
+            let start = s_start.offset_from(md_start) as usize;
+            let end = s_end.offset_from(md_start) as usize;
+            start..end
+        } else {
+            fallback
+        }
+    };
+
+    let span_for_link = |link: &CowStr<'_>, span: Range<usize>| {
+        // For diagnostics, we want to underline the link's definition but `span` will point at
+        // where the link is used. This is a problem for reference-style links, where the definition
+        // is separate from the usage.
+        match link {
+            // `Borrowed` variant means the string (the link's destination) may come directly from
+            // the markdown text and we can locate the original link destination.
+            // NOTE: LinkReplacer also provides `Borrowed` but possibly from other sources,
+            // so `locate()` can fall back to use `span`.
+            CowStr::Borrowed(s) => locate(s, span),
+
+            // For anything else, we can only use the provided range.
+            CowStr::Boxed(_) | CowStr::Inlined(_) => span,
+        }
+    };
+
+    let mut push = |link: BrokenLink<'_>| {
+        let span = span_for_link(&link.reference, link.span);
+        filter_map(MarkdownLink {
+            kind: LinkType::ShortcutUnknown,
+            link: link.reference.to_string(),
+            range: span,
+        })
+        .map(|link| links.borrow_mut().push(link));
+        None
+    };
+    let p = Parser::new_with_broken_link_callback(md, main_body_opts(), Some(&mut push))
+        .into_offset_iter();
+
+    // There's no need to thread an IdMap through to here because
+    // the IDs generated aren't going to be emitted anywhere.
+    let mut ids = IdMap::new();
+    let iter = Footnotes::new(HeadingLinks::new(p, None, &mut ids, HeadingOffset::H1));
+
+    for ev in iter {
+        if let Event::Start(Tag::Link(
+            // `<>` links cannot be intra-doc links so we skip them.
+            kind @ (LinkType::Inline
+            | LinkType::Reference
+            | LinkType::ReferenceUnknown
+            | LinkType::Collapsed
+            | LinkType::CollapsedUnknown
+            | LinkType::Shortcut
+            | LinkType::ShortcutUnknown),
+            dest,
+            _,
+        )) = ev.0
+        {
+            debug!("found link: {dest}");
+            let span = span_for_link(&dest, ev.1);
+            filter_map(MarkdownLink { kind, link: dest.into_string(), range: span })
+                .map(|link| links.borrow_mut().push(link));
+        }
+    }
+
+    links.into_inner()
+}
+
+#[derive(Debug)]
+pub(crate) struct RustCodeBlock {
+    /// The range in the markdown that the code block occupies. Note that this includes the fences
+    /// for fenced code blocks.
+    pub(crate) range: Range<usize>,
+    /// The range in the markdown that the code within the code block occupies.
+    pub(crate) code: Range<usize>,
+    pub(crate) is_fenced: bool,
+    pub(crate) lang_string: LangString,
+}
+
+/// Returns a range of bytes for each code block in the markdown that is tagged as `rust` or
+/// untagged (and assumed to be rust).
+pub(crate) fn rust_code_blocks(md: &str, extra_info: &ExtraInfo<'_>) -> Vec<RustCodeBlock> {
+    let mut code_blocks = vec![];
+
+    if md.is_empty() {
+        return code_blocks;
+    }
+
+    let mut p = Parser::new_ext(md, main_body_opts()).into_offset_iter();
+
+    while let Some((event, offset)) = p.next() {
+        if let Event::Start(Tag::CodeBlock(syntax)) = event {
+            let (lang_string, code_start, code_end, range, is_fenced) = match syntax {
+                CodeBlockKind::Fenced(syntax) => {
+                    let syntax = syntax.as_ref();
+                    let lang_string = if syntax.is_empty() {
+                        Default::default()
+                    } else {
+                        LangString::parse(&*syntax, ErrorCodes::Yes, false, Some(extra_info))
+                    };
+                    if !lang_string.rust {
+                        continue;
+                    }
+                    let (code_start, mut code_end) = match p.next() {
+                        Some((Event::Text(_), offset)) => (offset.start, offset.end),
+                        Some((_, sub_offset)) => {
+                            let code = Range { start: sub_offset.start, end: sub_offset.start };
+                            code_blocks.push(RustCodeBlock {
+                                is_fenced: true,
+                                range: offset,
+                                code,
+                                lang_string,
+                            });
+                            continue;
+                        }
+                        None => {
+                            let code = Range { start: offset.end, end: offset.end };
+                            code_blocks.push(RustCodeBlock {
+                                is_fenced: true,
+                                range: offset,
+                                code,
+                                lang_string,
+                            });
+                            continue;
+                        }
+                    };
+                    while let Some((Event::Text(_), offset)) = p.next() {
+                        code_end = offset.end;
+                    }
+                    (lang_string, code_start, code_end, offset, true)
+                }
+                CodeBlockKind::Indented => {
+                    // The ending of the offset goes too far sometime so we reduce it by one in
+                    // these cases.
+                    if offset.end > offset.start && md.get(offset.end..=offset.end) == Some("\n") {
+                        (
+                            LangString::default(),
+                            offset.start,
+                            offset.end,
+                            Range { start: offset.start, end: offset.end - 1 },
+                            false,
+                        )
+                    } else {
+                        (LangString::default(), offset.start, offset.end, offset, false)
+                    }
+                }
+            };
+
+            code_blocks.push(RustCodeBlock {
+                is_fenced,
+                range,
+                code: Range { start: code_start, end: code_end },
+                lang_string,
+            });
+        }
+    }
+
+    code_blocks
+}
+
+#[derive(Clone, Default, Debug)]
+pub struct IdMap {
+    map: FxHashMap<Cow<'static, str>, usize>,
+}
+
+// The map is pre-initialized and cloned each time to avoid reinitializing it repeatedly.
+static DEFAULT_ID_MAP: Lazy<FxHashMap<Cow<'static, str>, usize>> = Lazy::new(|| init_id_map());
+
+fn init_id_map() -> FxHashMap<Cow<'static, str>, usize> {
+    let mut map = FxHashMap::default();
+    // This is the list of IDs used in Javascript.
+    map.insert("settings".into(), 1);
+    map.insert("not-displayed".into(), 1);
+    map.insert("alternative-display".into(), 1);
+    map.insert("search".into(), 1);
+    // This is the list of IDs used in HTML generated in Rust (including the ones
+    // used in tera template files).
+    map.insert("mainThemeStyle".into(), 1);
+    map.insert("themeStyle".into(), 1);
+    map.insert("settings-menu".into(), 1);
+    map.insert("help-button".into(), 1);
+    map.insert("main-content".into(), 1);
+    map.insert("crate-search".into(), 1);
+    map.insert("toggle-all-docs".into(), 1);
+    map.insert("all-types".into(), 1);
+    map.insert("default-settings".into(), 1);
+    map.insert("rustdoc-vars".into(), 1);
+    map.insert("sidebar-vars".into(), 1);
+    map.insert("copy-path".into(), 1);
+    map.insert("TOC".into(), 1);
+    // This is the list of IDs used by rustdoc sections (but still generated by
+    // rustdoc).
+    map.insert("fields".into(), 1);
+    map.insert("variants".into(), 1);
+    map.insert("implementors-list".into(), 1);
+    map.insert("synthetic-implementors-list".into(), 1);
+    map.insert("foreign-impls".into(), 1);
+    map.insert("implementations".into(), 1);
+    map.insert("trait-implementations".into(), 1);
+    map.insert("synthetic-implementations".into(), 1);
+    map.insert("blanket-implementations".into(), 1);
+    map.insert("required-associated-types".into(), 1);
+    map.insert("provided-associated-types".into(), 1);
+    map.insert("provided-associated-consts".into(), 1);
+    map.insert("required-associated-consts".into(), 1);
+    map.insert("required-methods".into(), 1);
+    map.insert("provided-methods".into(), 1);
+    map.insert("implementors".into(), 1);
+    map.insert("synthetic-implementors".into(), 1);
+    map.insert("implementations-list".into(), 1);
+    map.insert("trait-implementations-list".into(), 1);
+    map.insert("synthetic-implementations-list".into(), 1);
+    map.insert("blanket-implementations-list".into(), 1);
+    map.insert("deref-methods".into(), 1);
+    map.insert("layout".into(), 1);
+    map
+}
+
+impl IdMap {
+    pub fn new() -> Self {
+        IdMap { map: DEFAULT_ID_MAP.clone() }
+    }
+
+    pub(crate) fn derive<S: AsRef<str> + ToString>(&mut self, candidate: S) -> String {
+        let id = match self.map.get_mut(candidate.as_ref()) {
+            None => candidate.to_string(),
+            Some(a) => {
+                let id = format!("{}-{}", candidate.as_ref(), *a);
+                *a += 1;
+                id
+            }
+        };
+
+        self.map.insert(id.clone().into(), 1);
+        id
+    }
+}
diff --git a/src/librustdoc/html/markdown/tests.rs b/src/librustdoc/html/markdown/tests.rs
new file mode 100644
index 000000000..5c0bf0ed9
--- /dev/null
+++ b/src/librustdoc/html/markdown/tests.rs
@@ -0,0 +1,312 @@
+use super::{find_testable_code, plain_text_summary, short_markdown_summary};
+use super::{ErrorCodes, HeadingOffset, IdMap, Ignore, LangString, Markdown, MarkdownHtml};
+use rustc_span::edition::{Edition, DEFAULT_EDITION};
+
+#[test]
+fn test_unique_id() {
+    let input = [
+        "foo",
+        "examples",
+        "examples",
+        "method.into_iter",
+        "examples",
+        "method.into_iter",
+        "foo",
+        "main-content",
+        "search",
+        "methods",
+        "examples",
+        "method.into_iter",
+        "assoc_type.Item",
+        "assoc_type.Item",
+    ];
+    let expected = [
+        "foo",
+        "examples",
+        "examples-1",
+        "method.into_iter",
+        "examples-2",
+        "method.into_iter-1",
+        "foo-1",
+        "main-content-1",
+        "search-1",
+        "methods",
+        "examples-3",
+        "method.into_iter-2",
+        "assoc_type.Item",
+        "assoc_type.Item-1",
+    ];
+
+    let mut map = IdMap::new();
+    let actual: Vec<String> = input.iter().map(|s| map.derive(s.to_string())).collect();
+    assert_eq!(&actual[..], expected);
+}
+
+#[test]
+fn test_lang_string_parse() {
+    fn t(lg: LangString) {
+        let s = &lg.original;
+        assert_eq!(LangString::parse(s, ErrorCodes::Yes, true, None), lg)
+    }
+
+    t(Default::default());
+    t(LangString { original: "rust".into(), ..Default::default() });
+    t(LangString { original: ".rust".into(), ..Default::default() });
+    t(LangString { original: "{rust}".into(), ..Default::default() });
+    t(LangString { original: "{.rust}".into(), ..Default::default() });
+    t(LangString { original: "sh".into(), rust: false, ..Default::default() });
+    t(LangString { original: "ignore".into(), ignore: Ignore::All, ..Default::default() });
+    t(LangString {
+        original: "ignore-foo".into(),
+        ignore: Ignore::Some(vec!["foo".to_string()]),
+        ..Default::default()
+    });
+    t(LangString { original: "should_panic".into(), should_panic: true, ..Default::default() });
+    t(LangString { original: "no_run".into(), no_run: true, ..Default::default() });
+    t(LangString { original: "test_harness".into(), test_harness: true, ..Default::default() });
+    t(LangString {
+        original: "compile_fail".into(),
+        no_run: true,
+        compile_fail: true,
+        ..Default::default()
+    });
+    t(LangString { original: "no_run,example".into(), no_run: true, ..Default::default() });
+    t(LangString {
+        original: "sh,should_panic".into(),
+        should_panic: true,
+        rust: false,
+        ..Default::default()
+    });
+    t(LangString { original: "example,rust".into(), ..Default::default() });
+    t(LangString {
+        original: "test_harness,.rust".into(),
+        test_harness: true,
+        ..Default::default()
+    });
+    t(LangString {
+        original: "text, no_run".into(),
+        no_run: true,
+        rust: false,
+        ..Default::default()
+    });
+    t(LangString {
+        original: "text,no_run".into(),
+        no_run: true,
+        rust: false,
+        ..Default::default()
+    });
+    t(LangString {
+        original: "text,no_run, ".into(),
+        no_run: true,
+        rust: false,
+        ..Default::default()
+    });
+    t(LangString {
+        original: "text,no_run,".into(),
+        no_run: true,
+        rust: false,
+        ..Default::default()
+    });
+    t(LangString {
+        original: "edition2015".into(),
+        edition: Some(Edition::Edition2015),
+        ..Default::default()
+    });
+    t(LangString {
+        original: "edition2018".into(),
+        edition: Some(Edition::Edition2018),
+        ..Default::default()
+    });
+}
+
+#[test]
+fn test_lang_string_tokenizer() {
+    fn case(lang_string: &str, want: &[&str]) {
+        let have = LangString::tokens(lang_string).collect::<Vec<&str>>();
+        assert_eq!(have, want, "Unexpected lang string split for `{}`", lang_string);
+    }
+
+    case("", &[]);
+    case("foo", &["foo"]);
+    case("foo,bar", &["foo", "bar"]);
+    case(".foo,.bar", &["foo", "bar"]);
+    case("{.foo,.bar}", &["foo", "bar"]);
+    case("  {.foo,.bar}  ", &["foo", "bar"]);
+    case("foo bar", &["foo", "bar"]);
+    case("foo\tbar", &["foo", "bar"]);
+    case("foo\t, bar", &["foo", "bar"]);
+    case(" foo , bar ", &["foo", "bar"]);
+    case(",,foo,,bar,,", &["foo", "bar"]);
+    case("foo=bar", &["foo=bar"]);
+    case("a-b-c", &["a-b-c"]);
+    case("a_b_c", &["a_b_c"]);
+}
+
+#[test]
+fn test_header() {
+    fn t(input: &str, expect: &str) {
+        let mut map = IdMap::new();
+        let output = Markdown {
+            content: input,
+            links: &[],
+            ids: &mut map,
+            error_codes: ErrorCodes::Yes,
+            edition: DEFAULT_EDITION,
+            playground: &None,
+            heading_offset: HeadingOffset::H2,
+        }
+        .into_string();
+        assert_eq!(output, expect, "original: {}", input);
+    }
+
+    t("# Foo bar", "<h2 id=\"foo-bar\"><a href=\"#foo-bar\">Foo bar</a></h2>");
+    t(
+        "## Foo-bar_baz qux",
+        "<h3 id=\"foo-bar_baz-qux\">\
+         <a href=\"#foo-bar_baz-qux\">Foo-bar_baz qux</a></h3>",
+    );
+    t(
+        "### **Foo** *bar* baz!?!& -_qux_-%",
+        "<h4 id=\"foo-bar-baz--qux-\">\
+            <a href=\"#foo-bar-baz--qux-\"><strong>Foo</strong> \
+            <em>bar</em> baz!?!&amp; -<em>qux</em>-%</a>\
+         </h4>",
+    );
+    t(
+        "#### **Foo?** & \\*bar?!*  _`baz`_ ❤ #qux",
+        "<h5 id=\"foo--bar--baz--qux\">\
+             <a href=\"#foo--bar--baz--qux\"><strong>Foo?</strong> &amp; *bar?!*  \
+             <em><code>baz</code></em> ❤ #qux</a>\
+         </h5>",
+    );
+}
+
+#[test]
+fn test_header_ids_multiple_blocks() {
+    let mut map = IdMap::new();
+    fn t(map: &mut IdMap, input: &str, expect: &str) {
+        let output = Markdown {
+            content: input,
+            links: &[],
+            ids: map,
+            error_codes: ErrorCodes::Yes,
+            edition: DEFAULT_EDITION,
+            playground: &None,
+            heading_offset: HeadingOffset::H2,
+        }
+        .into_string();
+        assert_eq!(output, expect, "original: {}", input);
+    }
+
+    t(&mut map, "# Example", "<h2 id=\"example\"><a href=\"#example\">Example</a></h2>");
+    t(&mut map, "# Panics", "<h2 id=\"panics\"><a href=\"#panics\">Panics</a></h2>");
+    t(&mut map, "# Example", "<h2 id=\"example-1\"><a href=\"#example-1\">Example</a></h2>");
+    t(&mut map, "# Search", "<h2 id=\"search-1\"><a href=\"#search-1\">Search</a></h2>");
+    t(&mut map, "# Example", "<h2 id=\"example-2\"><a href=\"#example-2\">Example</a></h2>");
+    t(&mut map, "# Panics", "<h2 id=\"panics-1\"><a href=\"#panics-1\">Panics</a></h2>");
+}
+
+#[test]
+fn test_short_markdown_summary() {
+    fn t(input: &str, expect: &str) {
+        let output = short_markdown_summary(input, &[][..]);
+        assert_eq!(output, expect, "original: {}", input);
+    }
+
+    t("", "");
+    t("hello [Rust](https://www.rust-lang.org) :)", "hello Rust :)");
+    t("*italic*", "<em>italic</em>");
+    t("**bold**", "<strong>bold</strong>");
+    t("Multi-line\nsummary", "Multi-line summary");
+    t("Hard-break  \nsummary", "Hard-break summary");
+    t("hello [Rust] :)\n\n[Rust]: https://www.rust-lang.org", "hello Rust :)");
+    t("hello [Rust](https://www.rust-lang.org \"Rust\") :)", "hello Rust :)");
+    t("dud [link]", "dud [link]");
+    t("code `let x = i32;` ...", "code <code>let x = i32;</code> …");
+    t("type `Type<'static>` ...", "type <code>Type&lt;&#39;static&gt;</code> …");
+    // Test to ensure escaping and length-limiting work well together.
+    // The output should be limited based on the input length,
+    // rather than the output, because escaped versions of characters
+    // are usually longer than how the character is actually displayed.
+    t(
+        "& & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & & &",
+        "&amp; &amp; &amp; &amp; &amp; &amp; &amp; &amp; &amp; &amp; &amp; &amp; \
+         &amp; &amp; &amp; &amp; &amp; &amp; &amp; &amp; &amp; &amp; &amp; &amp; \
+         &amp; &amp; &amp; &amp; &amp; …",
+    );
+    t("# top header", "top header");
+    t("# top header\n\nfollowed by a paragraph", "top header");
+    t("## header", "header");
+    t("first paragraph\n\nsecond paragraph", "first paragraph");
+    t("```\nfn main() {}\n```", "");
+    t("<div>hello</div>", "");
+    t(
+        "a *very*, **very** long first paragraph. it has lots of `inline code: Vec<T>`. and it has a [link](https://www.rust-lang.org).\nthat was a soft line break!  \nthat was a hard one\n\nsecond paragraph.",
+        "a <em>very</em>, <strong>very</strong> long first paragraph. it has lots of …",
+    );
+}
+
+#[test]
+fn test_plain_text_summary() {
+    fn t(input: &str, expect: &str) {
+        let output = plain_text_summary(input);
+        assert_eq!(output, expect, "original: {}", input);
+    }
+
+    t("", "");
+    t("hello [Rust](https://www.rust-lang.org) :)", "hello Rust :)");
+    t("**bold**", "bold");
+    t("Multi-line\nsummary", "Multi-line summary");
+    t("Hard-break  \nsummary", "Hard-break summary");
+    t("hello [Rust] :)\n\n[Rust]: https://www.rust-lang.org", "hello Rust :)");
+    t("hello [Rust](https://www.rust-lang.org \"Rust\") :)", "hello Rust :)");
+    t("dud [link]", "dud [link]");
+    t("code `let x = i32;` ...", "code `let x = i32;` …");
+    t("type `Type<'static>` ...", "type `Type<'static>` …");
+    t("# top header", "top header");
+    t("# top header\n\nfollowed by some text", "top header");
+    t("## header", "header");
+    t("first paragraph\n\nsecond paragraph", "first paragraph");
+    t("```\nfn main() {}\n```", "");
+    t("<div>hello</div>", "");
+    t(
+        "a *very*, **very** long first paragraph. it has lots of `inline code: Vec<T>`. and it has a [link](https://www.rust-lang.org).\nthat was a soft line break!  \nthat was a hard one\n\nsecond paragraph.",
+        "a very, very long first paragraph. it has lots of `inline code: Vec<T>`. and it has a link. that was a soft line break! that was a hard one",
+    );
+}
+
+#[test]
+fn test_markdown_html_escape() {
+    fn t(input: &str, expect: &str) {
+        let mut idmap = IdMap::new();
+        let output =
+            MarkdownHtml(input, &mut idmap, ErrorCodes::Yes, DEFAULT_EDITION, &None).into_string();
+        assert_eq!(output, expect, "original: {}", input);
+    }
+
+    t("`Struct<'a, T>`", "<p><code>Struct&lt;'a, T&gt;</code></p>\n");
+    t("Struct<'a, T>", "<p>Struct&lt;’a, T&gt;</p>\n");
+    t("Struct<br>", "<p>Struct&lt;br&gt;</p>\n");
+}
+
+#[test]
+fn test_find_testable_code_line() {
+    fn t(input: &str, expect: &[usize]) {
+        impl crate::doctest::Tester for Vec<usize> {
+            fn add_test(&mut self, _test: String, _config: LangString, line: usize) {
+                self.push(line);
+            }
+        }
+        let mut lines = Vec::<usize>::new();
+        find_testable_code(input, &mut lines, ErrorCodes::No, false, None);
+        assert_eq!(lines, expect);
+    }
+
+    t("", &[]);
+    t("```rust\n```", &[1]);
+    t(" ```rust\n```", &[1]);
+    t("\n```rust\n```", &[2]);
+    t("\n ```rust\n```", &[2]);
+    t("```rust\n```\n```rust\n```", &[1, 3]);
+    t("```rust\n```\n ```rust\n```", &[1, 3]);
+}
diff --git a/src/librustdoc/html/mod.rs b/src/librustdoc/html/mod.rs
new file mode 100644
index 000000000..481ed16c0
--- /dev/null
+++ b/src/librustdoc/html/mod.rs
@@ -0,0 +1,15 @@
+pub(crate) mod escape;
+pub(crate) mod format;
+pub(crate) mod highlight;
+pub(crate) mod layout;
+mod length_limit;
+// used by the error-index generator, so it needs to be public
+pub mod markdown;
+pub(crate) mod render;
+pub(crate) mod sources;
+pub(crate) mod static_files;
+pub(crate) mod toc;
+mod url_parts_builder;
+
+#[cfg(test)]
+mod tests;
diff --git a/src/librustdoc/html/render/context.rs b/src/librustdoc/html/render/context.rs
new file mode 100644
index 000000000..2ed7a6f1b
--- /dev/null
+++ b/src/librustdoc/html/render/context.rs
@@ -0,0 +1,762 @@
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io;
+use std::path::{Path, PathBuf};
+use std::rc::Rc;
+use std::sync::mpsc::{channel, Receiver};
+
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_hir::def_id::{DefId, LOCAL_CRATE};
+use rustc_middle::ty::TyCtxt;
+use rustc_session::Session;
+use rustc_span::edition::Edition;
+use rustc_span::source_map::FileName;
+use rustc_span::{sym, Symbol};
+
+use super::print_item::{full_path, item_path, print_item};
+use super::search_index::build_index;
+use super::write_shared::write_shared;
+use super::{
+    collect_spans_and_sources, print_sidebar, scrape_examples_help, AllTypes, LinkFromSrc, NameDoc,
+    StylePath, BASIC_KEYWORDS,
+};
+
+use crate::clean::{self, types::ExternalLocation, ExternalCrate};
+use crate::config::{ModuleSorting, RenderOptions};
+use crate::docfs::{DocFS, PathError};
+use crate::error::Error;
+use crate::formats::cache::Cache;
+use crate::formats::item_type::ItemType;
+use crate::formats::FormatRenderer;
+use crate::html::escape::Escape;
+use crate::html::format::{join_with_double_colon, Buffer};
+use crate::html::markdown::{self, plain_text_summary, ErrorCodes, IdMap};
+use crate::html::{layout, sources};
+use crate::scrape_examples::AllCallLocations;
+use crate::try_err;
+
+/// Major driving force in all rustdoc rendering. This contains information
+/// about where in the tree-like hierarchy rendering is occurring and controls
+/// how the current page is being rendered.
+///
+/// It is intended that this context is a lightweight object which can be fairly
+/// easily cloned because it is cloned per work-job (about once per item in the
+/// rustdoc tree).
+pub(crate) struct Context<'tcx> {
+    /// Current hierarchy of components leading down to what's currently being
+    /// rendered
+    pub(crate) current: Vec<Symbol>,
+    /// The current destination folder of where HTML artifacts should be placed.
+    /// This changes as the context descends into the module hierarchy.
+    pub(crate) dst: PathBuf,
+    /// A flag, which when `true`, will render pages which redirect to the
+    /// real location of an item. This is used to allow external links to
+    /// publicly reused items to redirect to the right location.
+    pub(super) render_redirect_pages: bool,
+    /// Tracks section IDs for `Deref` targets so they match in both the main
+    /// body and the sidebar.
+    pub(super) deref_id_map: FxHashMap<DefId, String>,
+    /// The map used to ensure all generated 'id=' attributes are unique.
+    pub(super) id_map: IdMap,
+    /// Shared mutable state.
+    ///
+    /// Issue for improving the situation: [#82381][]
+    ///
+    /// [#82381]: https://github.com/rust-lang/rust/issues/82381
+    pub(crate) shared: Rc<SharedContext<'tcx>>,
+    /// This flag indicates whether source links should be generated or not. If
+    /// the source files are present in the html rendering, then this will be
+    /// `true`.
+    pub(crate) include_sources: bool,
+}
+
+// `Context` is cloned a lot, so we don't want the size to grow unexpectedly.
+#[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
+rustc_data_structures::static_assert_size!(Context<'_>, 128);
+
+/// Shared mutable state used in [`Context`] and elsewhere.
+pub(crate) struct SharedContext<'tcx> {
+    pub(crate) tcx: TyCtxt<'tcx>,
+    /// The path to the crate root source minus the file name.
+    /// Used for simplifying paths to the highlighted source code files.
+    pub(crate) src_root: PathBuf,
+    /// This describes the layout of each page, and is not modified after
+    /// creation of the context (contains info like the favicon and added html).
+    pub(crate) layout: layout::Layout,
+    /// The local file sources we've emitted and their respective url-paths.
+    pub(crate) local_sources: FxHashMap<PathBuf, String>,
+    /// Show the memory layout of types in the docs.
+    pub(super) show_type_layout: bool,
+    /// The base-URL of the issue tracker for when an item has been tagged with
+    /// an issue number.
+    pub(super) issue_tracker_base_url: Option<String>,
+    /// The directories that have already been created in this doc run. Used to reduce the number
+    /// of spurious `create_dir_all` calls.
+    created_dirs: RefCell<FxHashSet<PathBuf>>,
+    /// This flag indicates whether listings of modules (in the side bar and documentation itself)
+    /// should be ordered alphabetically or in order of appearance (in the source code).
+    pub(super) module_sorting: ModuleSorting,
+    /// Additional CSS files to be added to the generated docs.
+    pub(crate) style_files: Vec<StylePath>,
+    /// Suffix to be added on resource files (if suffix is "-v2" then "light.css" becomes
+    /// "light-v2.css").
+    pub(crate) resource_suffix: String,
+    /// Optional path string to be used to load static files on output pages. If not set, uses
+    /// combinations of `../` to reach the documentation root.
+    pub(crate) static_root_path: Option<String>,
+    /// The fs handle we are working with.
+    pub(crate) fs: DocFS,
+    pub(super) codes: ErrorCodes,
+    pub(super) playground: Option<markdown::Playground>,
+    all: RefCell<AllTypes>,
+    /// Storage for the errors produced while generating documentation so they
+    /// can be printed together at the end.
+    errors: Receiver<String>,
+    /// `None` by default, depends on the `generate-redirect-map` option flag. If this field is set
+    /// to `Some(...)`, it'll store redirections and then generate a JSON file at the top level of
+    /// the crate.
+    redirections: Option<RefCell<FxHashMap<String, String>>>,
+
+    /// Correspondance map used to link types used in the source code pages to allow to click on
+    /// links to jump to the type's definition.
+    pub(crate) span_correspondance_map: FxHashMap<rustc_span::Span, LinkFromSrc>,
+    /// The [`Cache`] used during rendering.
+    pub(crate) cache: Cache,
+
+    pub(crate) call_locations: AllCallLocations,
+}
+
+impl SharedContext<'_> {
+    pub(crate) fn ensure_dir(&self, dst: &Path) -> Result<(), Error> {
+        let mut dirs = self.created_dirs.borrow_mut();
+        if !dirs.contains(dst) {
+            try_err!(self.fs.create_dir_all(dst), dst);
+            dirs.insert(dst.to_path_buf());
+        }
+
+        Ok(())
+    }
+
+    pub(crate) fn edition(&self) -> Edition {
+        self.tcx.sess.edition()
+    }
+}
+
+impl<'tcx> Context<'tcx> {
+    pub(crate) fn tcx(&self) -> TyCtxt<'tcx> {
+        self.shared.tcx
+    }
+
+    pub(crate) fn cache(&self) -> &Cache {
+        &self.shared.cache
+    }
+
+    pub(super) fn sess(&self) -> &'tcx Session {
+        self.shared.tcx.sess
+    }
+
+    pub(super) fn derive_id(&mut self, id: String) -> String {
+        self.id_map.derive(id)
+    }
+
+    /// String representation of how to get back to the root path of the 'doc/'
+    /// folder in terms of a relative URL.
+    pub(super) fn root_path(&self) -> String {
+        "../".repeat(self.current.len())
+    }
+
+    fn render_item(&mut self, it: &clean::Item, is_module: bool) -> String {
+        let mut title = String::new();
+        if !is_module {
+            title.push_str(it.name.unwrap().as_str());
+        }
+        if !it.is_primitive() && !it.is_keyword() {
+            if !is_module {
+                title.push_str(" in ");
+            }
+            // No need to include the namespace for primitive types and keywords
+            title.push_str(&join_with_double_colon(&self.current));
+        };
+        title.push_str(" - Rust");
+        let tyname = it.type_();
+        let desc = it.doc_value().as_ref().map(|doc| plain_text_summary(doc));
+        let desc = if let Some(desc) = desc {
+            desc
+        } else if it.is_crate() {
+            format!("API documentation for the Rust `{}` crate.", self.shared.layout.krate)
+        } else {
+            format!(
+                "API documentation for the Rust `{}` {} in crate `{}`.",
+                it.name.as_ref().unwrap(),
+                tyname,
+                self.shared.layout.krate
+            )
+        };
+        let keywords = make_item_keywords(it);
+        let name;
+        let tyname_s = if it.is_crate() {
+            name = format!("{} crate", tyname);
+            name.as_str()
+        } else {
+            tyname.as_str()
+        };
+
+        if !self.render_redirect_pages {
+            let clone_shared = Rc::clone(&self.shared);
+            let page = layout::Page {
+                css_class: tyname_s,
+                root_path: &self.root_path(),
+                static_root_path: clone_shared.static_root_path.as_deref(),
+                title: &title,
+                description: &desc,
+                keywords: &keywords,
+                resource_suffix: &clone_shared.resource_suffix,
+            };
+            let mut page_buffer = Buffer::html();
+            print_item(self, it, &mut page_buffer, &page);
+            layout::render(
+                &clone_shared.layout,
+                &page,
+                |buf: &mut _| print_sidebar(self, it, buf),
+                move |buf: &mut Buffer| buf.push_buffer(page_buffer),
+                &clone_shared.style_files,
+            )
+        } else {
+            if let Some(&(ref names, ty)) = self.cache().paths.get(&it.item_id.expect_def_id()) {
+                if self.current.len() + 1 != names.len()
+                    || self.current.iter().zip(names.iter()).any(|(a, b)| a != b)
+                {
+                    // We checked that the redirection isn't pointing to the current file,
+                    // preventing an infinite redirection loop in the generated
+                    // documentation.
+
+                    let mut path = String::new();
+                    for name in &names[..names.len() - 1] {
+                        path.push_str(name.as_str());
+                        path.push('/');
+                    }
+                    path.push_str(&item_path(ty, names.last().unwrap().as_str()));
+                    match self.shared.redirections {
+                        Some(ref redirections) => {
+                            let mut current_path = String::new();
+                            for name in &self.current {
+                                current_path.push_str(name.as_str());
+                                current_path.push('/');
+                            }
+                            current_path.push_str(&item_path(ty, names.last().unwrap().as_str()));
+                            redirections.borrow_mut().insert(current_path, path);
+                        }
+                        None => return layout::redirect(&format!("{}{}", self.root_path(), path)),
+                    }
+                }
+            }
+            String::new()
+        }
+    }
+
+    /// Construct a map of items shown in the sidebar to a plain-text summary of their docs.
+    fn build_sidebar_items(&self, m: &clean::Module) -> BTreeMap<String, Vec<NameDoc>> {
+        // BTreeMap instead of HashMap to get a sorted output
+        let mut map: BTreeMap<_, Vec<_>> = BTreeMap::new();
+        let mut inserted: FxHashMap<ItemType, FxHashSet<Symbol>> = FxHashMap::default();
+
+        for item in &m.items {
+            if item.is_stripped() {
+                continue;
+            }
+
+            let short = item.type_();
+            let myname = match item.name {
+                None => continue,
+                Some(s) => s,
+            };
+            if inserted.entry(short).or_default().insert(myname) {
+                let short = short.to_string();
+                let myname = myname.to_string();
+                map.entry(short).or_default().push((
+                    myname,
+                    Some(item.doc_value().map_or_else(String::new, |s| plain_text_summary(&s))),
+                ));
+            }
+        }
+
+        match self.shared.module_sorting {
+            ModuleSorting::Alphabetical => {
+                for items in map.values_mut() {
+                    items.sort();
+                }
+            }
+            ModuleSorting::DeclarationOrder => {}
+        }
+        map
+    }
+
+    /// Generates a url appropriate for an `href` attribute back to the source of
+    /// this item.
+    ///
+    /// The url generated, when clicked, will redirect the browser back to the
+    /// original source code.
+    ///
+    /// If `None` is returned, then a source link couldn't be generated. This
+    /// may happen, for example, with externally inlined items where the source
+    /// of their crate documentation isn't known.
+    pub(super) fn src_href(&self, item: &clean::Item) -> Option<String> {
+        self.href_from_span(item.span(self.tcx()), true)
+    }
+
+    pub(crate) fn href_from_span(&self, span: clean::Span, with_lines: bool) -> Option<String> {
+        if span.is_dummy() {
+            return None;
+        }
+        let mut root = self.root_path();
+        let mut path = String::new();
+        let cnum = span.cnum(self.sess());
+
+        // We can safely ignore synthetic `SourceFile`s.
+        let file = match span.filename(self.sess()) {
+            FileName::Real(ref path) => path.local_path_if_available().to_path_buf(),
+            _ => return None,
+        };
+        let file = &file;
+
+        let krate_sym;
+        let (krate, path) = if cnum == LOCAL_CRATE {
+            if let Some(path) = self.shared.local_sources.get(file) {
+                (self.shared.layout.krate.as_str(), path)
+            } else {
+                return None;
+            }
+        } else {
+            let (krate, src_root) = match *self.cache().extern_locations.get(&cnum)? {
+                ExternalLocation::Local => {
+                    let e = ExternalCrate { crate_num: cnum };
+                    (e.name(self.tcx()), e.src_root(self.tcx()))
+                }
+                ExternalLocation::Remote(ref s) => {
+                    root = s.to_string();
+                    let e = ExternalCrate { crate_num: cnum };
+                    (e.name(self.tcx()), e.src_root(self.tcx()))
+                }
+                ExternalLocation::Unknown => return None,
+            };
+
+            sources::clean_path(&src_root, file, false, |component| {
+                path.push_str(&component.to_string_lossy());
+                path.push('/');
+            });
+            let mut fname = file.file_name().expect("source has no filename").to_os_string();
+            fname.push(".html");
+            path.push_str(&fname.to_string_lossy());
+            krate_sym = krate;
+            (krate_sym.as_str(), &path)
+        };
+
+        let anchor = if with_lines {
+            let loline = span.lo(self.sess()).line;
+            let hiline = span.hi(self.sess()).line;
+            format!(
+                "#{}",
+                if loline == hiline {
+                    loline.to_string()
+                } else {
+                    format!("{}-{}", loline, hiline)
+                }
+            )
+        } else {
+            "".to_string()
+        };
+        Some(format!(
+            "{root}src/{krate}/{path}{anchor}",
+            root = Escape(&root),
+            krate = krate,
+            path = path,
+            anchor = anchor
+        ))
+    }
+}
+
+/// Generates the documentation for `crate` into the directory `dst`
+impl<'tcx> FormatRenderer<'tcx> for Context<'tcx> {
+    fn descr() -> &'static str {
+        "html"
+    }
+
+    const RUN_ON_MODULE: bool = true;
+
+    fn init(
+        krate: clean::Crate,
+        options: RenderOptions,
+        cache: Cache,
+        tcx: TyCtxt<'tcx>,
+    ) -> Result<(Self, clean::Crate), Error> {
+        // need to save a copy of the options for rendering the index page
+        let md_opts = options.clone();
+        let emit_crate = options.should_emit_crate();
+        let RenderOptions {
+            output,
+            external_html,
+            id_map,
+            playground_url,
+            module_sorting,
+            themes: style_files,
+            default_settings,
+            extension_css,
+            resource_suffix,
+            static_root_path,
+            unstable_features,
+            generate_redirect_map,
+            show_type_layout,
+            generate_link_to_definition,
+            call_locations,
+            no_emit_shared,
+            ..
+        } = options;
+
+        let src_root = match krate.src(tcx) {
+            FileName::Real(ref p) => match p.local_path_if_available().parent() {
+                Some(p) => p.to_path_buf(),
+                None => PathBuf::new(),
+            },
+            _ => PathBuf::new(),
+        };
+        // If user passed in `--playground-url` arg, we fill in crate name here
+        let mut playground = None;
+        if let Some(url) = playground_url {
+            playground =
+                Some(markdown::Playground { crate_name: Some(krate.name(tcx).to_string()), url });
+        }
+        let mut layout = layout::Layout {
+            logo: String::new(),
+            favicon: String::new(),
+            external_html,
+            default_settings,
+            krate: krate.name(tcx).to_string(),
+            css_file_extension: extension_css,
+            scrape_examples_extension: !call_locations.is_empty(),
+        };
+        let mut issue_tracker_base_url = None;
+        let mut include_sources = true;
+
+        // Crawl the crate attributes looking for attributes which control how we're
+        // going to emit HTML
+        for attr in krate.module.attrs.lists(sym::doc) {
+            match (attr.name_or_empty(), attr.value_str()) {
+                (sym::html_favicon_url, Some(s)) => {
+                    layout.favicon = s.to_string();
+                }
+                (sym::html_logo_url, Some(s)) => {
+                    layout.logo = s.to_string();
+                }
+                (sym::html_playground_url, Some(s)) => {
+                    playground = Some(markdown::Playground {
+                        crate_name: Some(krate.name(tcx).to_string()),
+                        url: s.to_string(),
+                    });
+                }
+                (sym::issue_tracker_base_url, Some(s)) => {
+                    issue_tracker_base_url = Some(s.to_string());
+                }
+                (sym::html_no_source, None) if attr.is_word() => {
+                    include_sources = false;
+                }
+                _ => {}
+            }
+        }
+
+        let (local_sources, matches) = collect_spans_and_sources(
+            tcx,
+            &krate,
+            &src_root,
+            include_sources,
+            generate_link_to_definition,
+        );
+
+        let (sender, receiver) = channel();
+        let mut scx = SharedContext {
+            tcx,
+            src_root,
+            local_sources,
+            issue_tracker_base_url,
+            layout,
+            created_dirs: Default::default(),
+            module_sorting,
+            style_files,
+            resource_suffix,
+            static_root_path,
+            fs: DocFS::new(sender),
+            codes: ErrorCodes::from(unstable_features.is_nightly_build()),
+            playground,
+            all: RefCell::new(AllTypes::new()),
+            errors: receiver,
+            redirections: if generate_redirect_map { Some(Default::default()) } else { None },
+            show_type_layout,
+            span_correspondance_map: matches,
+            cache,
+            call_locations,
+        };
+
+        // Add the default themes to the `Vec` of stylepaths
+        //
+        // Note that these must be added before `sources::render` is called
+        // so that the resulting source pages are styled
+        //
+        // `light.css` is not disabled because it is the stylesheet that stays loaded
+        // by the browser as the theme stylesheet. The theme system (hackily) works by
+        // changing the href to this stylesheet. All other themes are disabled to
+        // prevent rule conflicts
+        scx.style_files.push(StylePath { path: PathBuf::from("light.css") });
+        scx.style_files.push(StylePath { path: PathBuf::from("dark.css") });
+        scx.style_files.push(StylePath { path: PathBuf::from("ayu.css") });
+
+        let dst = output;
+        scx.ensure_dir(&dst)?;
+
+        let mut cx = Context {
+            current: Vec::new(),
+            dst,
+            render_redirect_pages: false,
+            id_map,
+            deref_id_map: FxHashMap::default(),
+            shared: Rc::new(scx),
+            include_sources,
+        };
+
+        if emit_crate {
+            sources::render(&mut cx, &krate)?;
+        }
+
+        if !no_emit_shared {
+            // Build our search index
+            let index = build_index(&krate, &mut Rc::get_mut(&mut cx.shared).unwrap().cache, tcx);
+
+            // Write shared runs within a flock; disable thread dispatching of IO temporarily.
+            Rc::get_mut(&mut cx.shared).unwrap().fs.set_sync_only(true);
+            write_shared(&mut cx, &krate, index, &md_opts)?;
+            Rc::get_mut(&mut cx.shared).unwrap().fs.set_sync_only(false);
+        }
+
+        Ok((cx, krate))
+    }
+
+    fn make_child_renderer(&self) -> Self {
+        Self {
+            current: self.current.clone(),
+            dst: self.dst.clone(),
+            render_redirect_pages: self.render_redirect_pages,
+            deref_id_map: FxHashMap::default(),
+            id_map: IdMap::new(),
+            shared: Rc::clone(&self.shared),
+            include_sources: self.include_sources,
+        }
+    }
+
+    fn after_krate(&mut self) -> Result<(), Error> {
+        let crate_name = self.tcx().crate_name(LOCAL_CRATE);
+        let final_file = self.dst.join(crate_name.as_str()).join("all.html");
+        let settings_file = self.dst.join("settings.html");
+        let scrape_examples_help_file = self.dst.join("scrape-examples-help.html");
+
+        let mut root_path = self.dst.to_str().expect("invalid path").to_owned();
+        if !root_path.ends_with('/') {
+            root_path.push('/');
+        }
+        let shared = Rc::clone(&self.shared);
+        let mut page = layout::Page {
+            title: "List of all items in this crate",
+            css_class: "mod",
+            root_path: "../",
+            static_root_path: shared.static_root_path.as_deref(),
+            description: "List of all items in this crate",
+            keywords: BASIC_KEYWORDS,
+            resource_suffix: &shared.resource_suffix,
+        };
+        let sidebar = if shared.cache.crate_version.is_some() {
+            format!("<h2 class=\"location\">Crate {}</h2>", crate_name)
+        } else {
+            String::new()
+        };
+        let all = shared.all.replace(AllTypes::new());
+        let v = layout::render(
+            &shared.layout,
+            &page,
+            sidebar,
+            |buf: &mut Buffer| all.print(buf),
+            &shared.style_files,
+        );
+        shared.fs.write(final_file, v)?;
+
+        // Generating settings page.
+        page.title = "Rustdoc settings";
+        page.description = "Settings of Rustdoc";
+        page.root_path = "./";
+
+        let sidebar = "<h2 class=\"location\">Settings</h2><div class=\"sidebar-elems\"></div>";
+        let v = layout::render(
+            &shared.layout,
+            &page,
+            sidebar,
+            |buf: &mut Buffer| {
+                write!(
+                    buf,
+                    "<div class=\"main-heading\">\
+                     <h1 class=\"fqn\">\
+                         <span class=\"in-band\">Rustdoc settings</span>\
+                     </h1>\
+                     <span class=\"out-of-band\">\
+                         <a id=\"back\" href=\"javascript:void(0)\" onclick=\"history.back();\">\
+                            Back\
+                        </a>\
+                     </span>\
+                     </div>\
+                     <noscript>\
+                        <section>\
+                            You need to enable Javascript be able to update your settings.\
+                        </section>\
+                     </noscript>\
+                     <link rel=\"stylesheet\" type=\"text/css\" \
+                         href=\"{root_path}settings{suffix}.css\">\
+                     <script defer src=\"{root_path}settings{suffix}.js\"></script>",
+                    root_path = page.static_root_path.unwrap_or(""),
+                    suffix = page.resource_suffix,
+                )
+            },
+            &shared.style_files,
+        );
+        shared.fs.write(settings_file, v)?;
+
+        if shared.layout.scrape_examples_extension {
+            page.title = "About scraped examples";
+            page.description = "How the scraped examples feature works in Rustdoc";
+            let v = layout::render(
+                &shared.layout,
+                &page,
+                "",
+                scrape_examples_help(&*shared),
+                &shared.style_files,
+            );
+            shared.fs.write(scrape_examples_help_file, v)?;
+        }
+
+        if let Some(ref redirections) = shared.redirections {
+            if !redirections.borrow().is_empty() {
+                let redirect_map_path =
+                    self.dst.join(crate_name.as_str()).join("redirect-map.json");
+                let paths = serde_json::to_string(&*redirections.borrow()).unwrap();
+                shared.ensure_dir(&self.dst.join(crate_name.as_str()))?;
+                shared.fs.write(redirect_map_path, paths)?;
+            }
+        }
+
+        // No need for it anymore.
+        drop(shared);
+
+        // Flush pending errors.
+        Rc::get_mut(&mut self.shared).unwrap().fs.close();
+        let nb_errors =
+            self.shared.errors.iter().map(|err| self.tcx().sess.struct_err(&err).emit()).count();
+        if nb_errors > 0 {
+            Err(Error::new(io::Error::new(io::ErrorKind::Other, "I/O error"), ""))
+        } else {
+            Ok(())
+        }
+    }
+
+    fn mod_item_in(&mut self, item: &clean::Item) -> Result<(), Error> {
+        // Stripped modules survive the rustdoc passes (i.e., `strip-private`)
+        // if they contain impls for public types. These modules can also
+        // contain items such as publicly re-exported structures.
+        //
+        // External crates will provide links to these structures, so
+        // these modules are recursed into, but not rendered normally
+        // (a flag on the context).
+        if !self.render_redirect_pages {
+            self.render_redirect_pages = item.is_stripped();
+        }
+        let item_name = item.name.unwrap();
+        self.dst.push(&*item_name.as_str());
+        self.current.push(item_name);
+
+        info!("Recursing into {}", self.dst.display());
+
+        let buf = self.render_item(item, true);
+        // 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");
+            self.shared.fs.write(joint_dst, buf)?;
+        }
+
+        // Render sidebar-items.js used throughout this module.
+        if !self.render_redirect_pages {
+            let (clean::StrippedItem(box clean::ModuleItem(ref module)) | clean::ModuleItem(ref module)) = *item.kind
+            else { unreachable!() };
+            let items = self.build_sidebar_items(module);
+            let js_dst = self.dst.join(&format!("sidebar-items{}.js", self.shared.resource_suffix));
+            let v = format!("window.SIDEBAR_ITEMS = {};", serde_json::to_string(&items).unwrap());
+            self.shared.fs.write(js_dst, v)?;
+        }
+        Ok(())
+    }
+
+    fn mod_item_out(&mut self) -> Result<(), Error> {
+        info!("Recursed; leaving {}", self.dst.display());
+
+        // Go back to where we were at
+        self.dst.pop();
+        self.current.pop();
+        Ok(())
+    }
+
+    fn item(&mut self, item: clean::Item) -> Result<(), Error> {
+        // Stripped modules survive the rustdoc passes (i.e., `strip-private`)
+        // if they contain impls for public types. These modules can also
+        // contain items such as publicly re-exported structures.
+        //
+        // External crates will provide links to these structures, so
+        // these modules are recursed into, but not rendered normally
+        // (a flag on the context).
+        if !self.render_redirect_pages {
+            self.render_redirect_pages = item.is_stripped();
+        }
+
+        let buf = self.render_item(&item, false);
+        // 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.as_str());
+            self.shared.ensure_dir(&self.dst)?;
+            let joint_dst = self.dst.join(file_name);
+            self.shared.fs.write(joint_dst, buf)?;
+
+            if !self.render_redirect_pages {
+                self.shared.all.borrow_mut().append(full_path(self, &item), &item_type);
+            }
+            // 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);
+                if let Some(ref redirections) = self.shared.redirections {
+                    let crate_name = &self.shared.layout.krate;
+                    redirections.borrow_mut().insert(
+                        format!("{}/{}", crate_name, redir_name),
+                        format!("{}/{}", crate_name, file_name),
+                    );
+                } else {
+                    let v = layout::redirect(file_name);
+                    let redir_dst = self.dst.join(redir_name);
+                    self.shared.fs.write(redir_dst, v)?;
+                }
+            }
+        }
+        Ok(())
+    }
+
+    fn cache(&self) -> &Cache {
+        &self.shared.cache
+    }
+}
+
+fn make_item_keywords(it: &clean::Item) -> String {
+    format!("{}, {}", BASIC_KEYWORDS, it.name.as_ref().unwrap())
+}
diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs
new file mode 100644
index 000000000..a262c8f7d
--- /dev/null
+++ b/src/librustdoc/html/render/mod.rs
@@ -0,0 +1,2849 @@
+//! Rustdoc's HTML rendering module.
+//!
+//! This modules contains the bulk of the logic necessary for rendering a
+//! rustdoc `clean::Crate` instance to a set of static HTML pages. This
+//! rendering process is largely driven by the `format!` syntax extension to
+//! perform all I/O into files and streams.
+//!
+//! The rendering process is largely driven by the `Context` and `Cache`
+//! structures. The cache is pre-populated by crawling the crate in question,
+//! and then it is shared among the various rendering threads. The cache is meant
+//! to be a fairly large structure not implementing `Clone` (because it's shared
+//! among threads). The context, however, should be a lightweight structure. This
+//! is cloned per-thread and contains information about what is currently being
+//! rendered.
+//!
+//! In order to speed up rendering (mostly because of markdown rendering), the
+//! rendering process has been parallelized. This parallelization is only
+//! exposed through the `crate` method on the context, and then also from the
+//! fact that the shared cache is stored in TLS (and must be accessed as such).
+//!
+//! In addition to rendering the crate itself, this module is also responsible
+//! for creating the corresponding search index and source file renderings.
+//! These threads are not parallelized (they haven't been a bottleneck yet), and
+//! both occur before the crate is rendered.
+
+pub(crate) mod search_index;
+
+#[cfg(test)]
+mod tests;
+
+mod context;
+mod print_item;
+mod span_map;
+mod write_shared;
+
+pub(crate) use self::context::*;
+pub(crate) use self::span_map::{collect_spans_and_sources, LinkFromSrc};
+
+use std::collections::VecDeque;
+use std::default::Default;
+use std::fmt;
+use std::fs;
+use std::iter::Peekable;
+use std::path::PathBuf;
+use std::rc::Rc;
+use std::str;
+use std::string::ToString;
+
+use rustc_ast_pretty::pprust;
+use rustc_attr::{ConstStability, Deprecation, StabilityLevel};
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_hir::def::CtorKind;
+use rustc_hir::def_id::DefId;
+use rustc_hir::Mutability;
+use rustc_middle::middle::stability;
+use rustc_middle::ty;
+use rustc_middle::ty::TyCtxt;
+use rustc_span::{
+    symbol::{sym, Symbol},
+    BytePos, FileName, RealFileName,
+};
+use serde::ser::SerializeSeq;
+use serde::{Serialize, Serializer};
+
+use crate::clean::{self, ItemId, RenderedLink, SelfTy};
+use crate::error::Error;
+use crate::formats::cache::Cache;
+use crate::formats::item_type::ItemType;
+use crate::formats::{AssocItemRender, Impl, RenderMode};
+use crate::html::escape::Escape;
+use crate::html::format::{
+    href, join_with_double_colon, print_abi_with_space, print_constness_with_space,
+    print_default_space, print_generic_bounds, print_where_clause, Buffer, Ending, HrefError,
+    PrintWithSpace,
+};
+use crate::html::highlight;
+use crate::html::markdown::{HeadingOffset, IdMap, Markdown, MarkdownHtml, MarkdownSummaryLine};
+use crate::html::sources;
+use crate::html::static_files::SCRAPE_EXAMPLES_HELP_MD;
+use crate::scrape_examples::{CallData, CallLocation};
+use crate::try_none;
+use crate::DOC_RUST_LANG_ORG_CHANNEL;
+
+/// A pair of name and its optional document.
+pub(crate) type NameDoc = (String, Option<String>);
+
+pub(crate) fn ensure_trailing_slash(v: &str) -> impl fmt::Display + '_ {
+    crate::html::format::display_fn(move |f| {
+        if !v.ends_with('/') && !v.is_empty() { write!(f, "{}/", v) } else { f.write_str(v) }
+    })
+}
+
+// Helper structs for rendering items/sidebars and carrying along contextual
+// information
+
+/// Struct representing one entry in the JS search index. These are all emitted
+/// by hand to a large JS file at the end of cache-creation.
+#[derive(Debug)]
+pub(crate) struct IndexItem {
+    pub(crate) ty: ItemType,
+    pub(crate) name: String,
+    pub(crate) path: String,
+    pub(crate) desc: String,
+    pub(crate) parent: Option<DefId>,
+    pub(crate) parent_idx: Option<usize>,
+    pub(crate) search_type: Option<IndexItemFunctionType>,
+    pub(crate) aliases: Box<[Symbol]>,
+}
+
+/// A type used for the search index.
+#[derive(Debug)]
+pub(crate) struct RenderType {
+    id: Option<RenderTypeId>,
+    generics: Option<Vec<RenderType>>,
+}
+
+impl Serialize for RenderType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let id = match &self.id {
+            // 0 is a sentinel, everything else is one-indexed
+            None => 0,
+            Some(RenderTypeId::Index(idx)) => idx + 1,
+            _ => panic!("must convert render types to indexes before serializing"),
+        };
+        if let Some(generics) = &self.generics {
+            let mut seq = serializer.serialize_seq(None)?;
+            seq.serialize_element(&id)?;
+            seq.serialize_element(generics)?;
+            seq.end()
+        } else {
+            id.serialize(serializer)
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+pub(crate) enum RenderTypeId {
+    DefId(DefId),
+    Primitive(clean::PrimitiveType),
+    Index(usize),
+}
+
+/// Full type of functions/methods in the search index.
+#[derive(Debug)]
+pub(crate) struct IndexItemFunctionType {
+    inputs: Vec<RenderType>,
+    output: Vec<RenderType>,
+}
+
+impl Serialize for IndexItemFunctionType {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        // If we couldn't figure out a type, just write `0`.
+        let has_missing = self
+            .inputs
+            .iter()
+            .chain(self.output.iter())
+            .any(|i| i.id.is_none() && i.generics.is_none());
+        if has_missing {
+            0.serialize(serializer)
+        } else {
+            let mut seq = serializer.serialize_seq(None)?;
+            match &self.inputs[..] {
+                [one] if one.generics.is_none() => seq.serialize_element(one)?,
+                _ => seq.serialize_element(&self.inputs)?,
+            }
+            match &self.output[..] {
+                [] => {}
+                [one] if one.generics.is_none() => seq.serialize_element(one)?,
+                _ => seq.serialize_element(&self.output)?,
+            }
+            seq.end()
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct StylePath {
+    /// The path to the theme
+    pub(crate) path: PathBuf,
+}
+
+impl StylePath {
+    pub(crate) fn basename(&self) -> Result<String, Error> {
+        Ok(try_none!(try_none!(self.path.file_stem(), &self.path).to_str(), &self.path).to_string())
+    }
+}
+
+fn write_srclink(cx: &Context<'_>, item: &clean::Item, buf: &mut Buffer) {
+    if let Some(l) = cx.src_href(item) {
+        write!(buf, "<a class=\"srclink\" href=\"{}\">source</a>", l)
+    }
+}
+
+#[derive(Debug, Eq, PartialEq, Hash)]
+struct ItemEntry {
+    url: String,
+    name: String,
+}
+
+impl ItemEntry {
+    fn new(mut url: String, name: String) -> ItemEntry {
+        while url.starts_with('/') {
+            url.remove(0);
+        }
+        ItemEntry { url, name }
+    }
+}
+
+impl ItemEntry {
+    pub(crate) fn print(&self) -> impl fmt::Display + '_ {
+        crate::html::format::display_fn(move |f| {
+            write!(f, "<a href=\"{}\">{}</a>", self.url, Escape(&self.name))
+        })
+    }
+}
+
+impl PartialOrd for ItemEntry {
+    fn partial_cmp(&self, other: &ItemEntry) -> Option<::std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for ItemEntry {
+    fn cmp(&self, other: &ItemEntry) -> ::std::cmp::Ordering {
+        self.name.cmp(&other.name)
+    }
+}
+
+#[derive(Debug)]
+struct AllTypes {
+    structs: FxHashSet<ItemEntry>,
+    enums: FxHashSet<ItemEntry>,
+    unions: FxHashSet<ItemEntry>,
+    primitives: FxHashSet<ItemEntry>,
+    traits: FxHashSet<ItemEntry>,
+    macros: FxHashSet<ItemEntry>,
+    functions: FxHashSet<ItemEntry>,
+    typedefs: FxHashSet<ItemEntry>,
+    opaque_tys: FxHashSet<ItemEntry>,
+    statics: FxHashSet<ItemEntry>,
+    constants: FxHashSet<ItemEntry>,
+    attributes: FxHashSet<ItemEntry>,
+    derives: FxHashSet<ItemEntry>,
+    trait_aliases: FxHashSet<ItemEntry>,
+}
+
+impl AllTypes {
+    fn new() -> AllTypes {
+        let new_set = |cap| FxHashSet::with_capacity_and_hasher(cap, Default::default());
+        AllTypes {
+            structs: new_set(100),
+            enums: new_set(100),
+            unions: new_set(100),
+            primitives: new_set(26),
+            traits: new_set(100),
+            macros: new_set(100),
+            functions: new_set(100),
+            typedefs: new_set(100),
+            opaque_tys: new_set(100),
+            statics: new_set(100),
+            constants: new_set(100),
+            attributes: new_set(100),
+            derives: new_set(100),
+            trait_aliases: new_set(100),
+        }
+    }
+
+    fn append(&mut self, item_name: String, item_type: &ItemType) {
+        let mut url: Vec<_> = item_name.split("::").skip(1).collect();
+        if let Some(name) = url.pop() {
+            let new_url = format!("{}/{}.{}.html", url.join("/"), item_type, name);
+            url.push(name);
+            let name = url.join("::");
+            match *item_type {
+                ItemType::Struct => self.structs.insert(ItemEntry::new(new_url, name)),
+                ItemType::Enum => self.enums.insert(ItemEntry::new(new_url, name)),
+                ItemType::Union => self.unions.insert(ItemEntry::new(new_url, name)),
+                ItemType::Primitive => self.primitives.insert(ItemEntry::new(new_url, name)),
+                ItemType::Trait => self.traits.insert(ItemEntry::new(new_url, name)),
+                ItemType::Macro => self.macros.insert(ItemEntry::new(new_url, name)),
+                ItemType::Function => self.functions.insert(ItemEntry::new(new_url, name)),
+                ItemType::Typedef => self.typedefs.insert(ItemEntry::new(new_url, name)),
+                ItemType::OpaqueTy => self.opaque_tys.insert(ItemEntry::new(new_url, name)),
+                ItemType::Static => self.statics.insert(ItemEntry::new(new_url, name)),
+                ItemType::Constant => self.constants.insert(ItemEntry::new(new_url, name)),
+                ItemType::ProcAttribute => self.attributes.insert(ItemEntry::new(new_url, name)),
+                ItemType::ProcDerive => self.derives.insert(ItemEntry::new(new_url, name)),
+                ItemType::TraitAlias => self.trait_aliases.insert(ItemEntry::new(new_url, name)),
+                _ => true,
+            };
+        }
+    }
+}
+
+impl AllTypes {
+    fn print(self, f: &mut Buffer) {
+        fn print_entries(f: &mut Buffer, e: &FxHashSet<ItemEntry>, title: &str, class: &str) {
+            if !e.is_empty() {
+                let mut e: Vec<&ItemEntry> = e.iter().collect();
+                e.sort();
+                write!(
+                    f,
+                    "<h3 id=\"{}\">{}</h3><ul class=\"{} docblock\">",
+                    title.replace(' ', "-"), // IDs cannot contain whitespaces.
+                    title,
+                    class
+                );
+
+                for s in e.iter() {
+                    write!(f, "<li>{}</li>", s.print());
+                }
+
+                f.write_str("</ul>");
+            }
+        }
+
+        f.write_str(
+            "<h1 class=\"fqn\">\
+                 <span class=\"in-band\">List of all items</span>\
+             </h1>",
+        );
+        // Note: print_entries does not escape the title, because we know the current set of titles
+        // doesn't require escaping.
+        print_entries(f, &self.structs, "Structs", "structs");
+        print_entries(f, &self.enums, "Enums", "enums");
+        print_entries(f, &self.unions, "Unions", "unions");
+        print_entries(f, &self.primitives, "Primitives", "primitives");
+        print_entries(f, &self.traits, "Traits", "traits");
+        print_entries(f, &self.macros, "Macros", "macros");
+        print_entries(f, &self.attributes, "Attribute Macros", "attributes");
+        print_entries(f, &self.derives, "Derive Macros", "derives");
+        print_entries(f, &self.functions, "Functions", "functions");
+        print_entries(f, &self.typedefs, "Typedefs", "typedefs");
+        print_entries(f, &self.trait_aliases, "Trait Aliases", "trait-aliases");
+        print_entries(f, &self.opaque_tys, "Opaque Types", "opaque-types");
+        print_entries(f, &self.statics, "Statics", "statics");
+        print_entries(f, &self.constants, "Constants", "constants")
+    }
+}
+
+fn scrape_examples_help(shared: &SharedContext<'_>) -> String {
+    let mut content = SCRAPE_EXAMPLES_HELP_MD.to_owned();
+    content.push_str(&format!(
+      "## More information\n\n\
+      If you want more information about this feature, please read the [corresponding chapter in the Rustdoc book]({}/rustdoc/scraped-examples.html).",
+      DOC_RUST_LANG_ORG_CHANNEL));
+
+    let mut ids = IdMap::default();
+    format!(
+        "<div class=\"main-heading\">\
+            <h1 class=\"fqn\">\
+                <span class=\"in-band\">About scraped examples</span>\
+            </h1>\
+        </div>\
+        <div>{}</div>",
+        Markdown {
+            content: &content,
+            links: &[],
+            ids: &mut ids,
+            error_codes: shared.codes,
+            edition: shared.edition(),
+            playground: &shared.playground,
+            heading_offset: HeadingOffset::H1
+        }
+        .into_string()
+    )
+}
+
+fn document(
+    w: &mut Buffer,
+    cx: &mut Context<'_>,
+    item: &clean::Item,
+    parent: Option<&clean::Item>,
+    heading_offset: HeadingOffset,
+) {
+    if let Some(ref name) = item.name {
+        info!("Documenting {}", name);
+    }
+    document_item_info(w, cx, item, parent);
+    if parent.is_none() {
+        document_full_collapsible(w, item, cx, heading_offset);
+    } else {
+        document_full(w, item, cx, heading_offset);
+    }
+}
+
+/// Render md_text as markdown.
+fn render_markdown(
+    w: &mut Buffer,
+    cx: &mut Context<'_>,
+    md_text: &str,
+    links: Vec<RenderedLink>,
+    heading_offset: HeadingOffset,
+) {
+    write!(
+        w,
+        "<div class=\"docblock\">{}</div>",
+        Markdown {
+            content: md_text,
+            links: &links,
+            ids: &mut cx.id_map,
+            error_codes: cx.shared.codes,
+            edition: cx.shared.edition(),
+            playground: &cx.shared.playground,
+            heading_offset,
+        }
+        .into_string()
+    )
+}
+
+/// Writes a documentation block containing only the first paragraph of the documentation. If the
+/// docs are longer, a "Read more" link is appended to the end.
+fn document_short(
+    w: &mut Buffer,
+    item: &clean::Item,
+    cx: &mut Context<'_>,
+    link: AssocItemLink<'_>,
+    parent: &clean::Item,
+    show_def_docs: bool,
+) {
+    document_item_info(w, cx, item, Some(parent));
+    if !show_def_docs {
+        return;
+    }
+    if let Some(s) = item.doc_value() {
+        let mut summary_html = MarkdownSummaryLine(&s, &item.links(cx)).into_string();
+
+        if s.contains('\n') {
+            let link = format!(r#" <a{}>Read more</a>"#, assoc_href_attr(item, link, cx));
+
+            if let Some(idx) = summary_html.rfind("</p>") {
+                summary_html.insert_str(idx, &link);
+            } else {
+                summary_html.push_str(&link);
+            }
+        }
+
+        write!(w, "<div class='docblock'>{}</div>", summary_html,);
+    }
+}
+
+fn document_full_collapsible(
+    w: &mut Buffer,
+    item: &clean::Item,
+    cx: &mut Context<'_>,
+    heading_offset: HeadingOffset,
+) {
+    document_full_inner(w, item, cx, true, heading_offset);
+}
+
+fn document_full(
+    w: &mut Buffer,
+    item: &clean::Item,
+    cx: &mut Context<'_>,
+    heading_offset: HeadingOffset,
+) {
+    document_full_inner(w, item, cx, false, heading_offset);
+}
+
+fn document_full_inner(
+    w: &mut Buffer,
+    item: &clean::Item,
+    cx: &mut Context<'_>,
+    is_collapsible: bool,
+    heading_offset: HeadingOffset,
+) {
+    if let Some(s) = item.collapsed_doc_value() {
+        debug!("Doc block: =====\n{}\n=====", s);
+        if is_collapsible {
+            w.write_str(
+                "<details class=\"rustdoc-toggle top-doc\" open>\
+                <summary class=\"hideme\">\
+                     <span>Expand description</span>\
+                </summary>",
+            );
+            render_markdown(w, cx, &s, item.links(cx), heading_offset);
+            w.write_str("</details>");
+        } else {
+            render_markdown(w, cx, &s, item.links(cx), heading_offset);
+        }
+    }
+
+    let kind = match &*item.kind {
+        clean::ItemKind::StrippedItem(box kind) | kind => kind,
+    };
+
+    if let clean::ItemKind::FunctionItem(..) | clean::ItemKind::MethodItem(..) = kind {
+        render_call_locations(w, cx, item);
+    }
+}
+
+/// Add extra information about an item such as:
+///
+/// * Stability
+/// * Deprecated
+/// * Required features (through the `doc_cfg` feature)
+fn document_item_info(
+    w: &mut Buffer,
+    cx: &mut Context<'_>,
+    item: &clean::Item,
+    parent: Option<&clean::Item>,
+) {
+    let item_infos = short_item_info(item, cx, parent);
+    if !item_infos.is_empty() {
+        w.write_str("<span class=\"item-info\">");
+        for info in item_infos {
+            w.write_str(&info);
+        }
+        w.write_str("</span>");
+    }
+}
+
+fn portability(item: &clean::Item, parent: Option<&clean::Item>) -> Option<String> {
+    let cfg = match (&item.cfg, parent.and_then(|p| p.cfg.as_ref())) {
+        (Some(cfg), Some(parent_cfg)) => cfg.simplify_with(parent_cfg),
+        (cfg, _) => cfg.as_deref().cloned(),
+    };
+
+    debug!("Portability {:?} - {:?} = {:?}", item.cfg, parent.and_then(|p| p.cfg.as_ref()), cfg);
+
+    Some(format!("<div class=\"stab portability\">{}</div>", cfg?.render_long_html()))
+}
+
+/// Render the stability, deprecation and portability information that is displayed at the top of
+/// the item's documentation.
+fn short_item_info(
+    item: &clean::Item,
+    cx: &mut Context<'_>,
+    parent: Option<&clean::Item>,
+) -> Vec<String> {
+    let mut extra_info = vec![];
+    let error_codes = cx.shared.codes;
+
+    if let Some(depr @ Deprecation { note, since, is_since_rustc_version: _, suggestion: _ }) =
+        item.deprecation(cx.tcx())
+    {
+        // We display deprecation messages for #[deprecated], but only display
+        // the future-deprecation messages for rustc versions.
+        let mut message = if let Some(since) = since {
+            let since = since.as_str();
+            if !stability::deprecation_in_effect(&depr) {
+                if since == "TBD" {
+                    String::from("Deprecating in a future Rust version")
+                } else {
+                    format!("Deprecating in {}", Escape(since))
+                }
+            } else {
+                format!("Deprecated since {}", Escape(since))
+            }
+        } else {
+            String::from("Deprecated")
+        };
+
+        if let Some(note) = note {
+            let note = note.as_str();
+            let html = MarkdownHtml(
+                note,
+                &mut cx.id_map,
+                error_codes,
+                cx.shared.edition(),
+                &cx.shared.playground,
+            );
+            message.push_str(&format!(": {}", html.into_string()));
+        }
+        extra_info.push(format!(
+            "<div class=\"stab deprecated\"><span class=\"emoji\">👎</span> {}</div>",
+            message,
+        ));
+    }
+
+    // Render unstable items. But don't render "rustc_private" crates (internal compiler crates).
+    // Those crates are permanently unstable so it makes no sense to render "unstable" everywhere.
+    if let Some((StabilityLevel::Unstable { reason: _, issue, .. }, feature)) = item
+        .stability(cx.tcx())
+        .as_ref()
+        .filter(|stab| stab.feature != sym::rustc_private)
+        .map(|stab| (stab.level, stab.feature))
+    {
+        let mut message =
+            "<span class=\"emoji\">🔬</span> This is a nightly-only experimental API.".to_owned();
+
+        let mut feature = format!("<code>{}</code>", Escape(feature.as_str()));
+        if let (Some(url), Some(issue)) = (&cx.shared.issue_tracker_base_url, issue) {
+            feature.push_str(&format!(
+                "&nbsp;<a href=\"{url}{issue}\">#{issue}</a>",
+                url = url,
+                issue = issue
+            ));
+        }
+
+        message.push_str(&format!(" ({})", feature));
+
+        extra_info.push(format!("<div class=\"stab unstable\">{}</div>", message));
+    }
+
+    if let Some(portability) = portability(item, parent) {
+        extra_info.push(portability);
+    }
+
+    extra_info
+}
+
+// Render the list of items inside one of the sections "Trait Implementations",
+// "Auto Trait Implementations," "Blanket Trait Implementations" (on struct/enum pages).
+fn render_impls(
+    cx: &mut Context<'_>,
+    w: &mut Buffer,
+    impls: &[&&Impl],
+    containing_item: &clean::Item,
+    toggle_open_by_default: bool,
+) {
+    let tcx = cx.tcx();
+    let mut rendered_impls = impls
+        .iter()
+        .map(|i| {
+            let did = i.trait_did().unwrap();
+            let provided_trait_methods = i.inner_impl().provided_trait_methods(tcx);
+            let assoc_link = AssocItemLink::GotoSource(did.into(), &provided_trait_methods);
+            let mut buffer = if w.is_for_html() { Buffer::html() } else { Buffer::new() };
+            render_impl(
+                &mut buffer,
+                cx,
+                i,
+                containing_item,
+                assoc_link,
+                RenderMode::Normal,
+                None,
+                &[],
+                ImplRenderingParameters {
+                    show_def_docs: true,
+                    show_default_items: true,
+                    show_non_assoc_items: true,
+                    toggle_open_by_default,
+                },
+            );
+            buffer.into_inner()
+        })
+        .collect::<Vec<_>>();
+    rendered_impls.sort();
+    w.write_str(&rendered_impls.join(""));
+}
+
+/// Build a (possibly empty) `href` attribute (a key-value pair) for the given associated item.
+fn assoc_href_attr(it: &clean::Item, link: AssocItemLink<'_>, cx: &Context<'_>) -> String {
+    let name = it.name.unwrap();
+    let item_type = it.type_();
+
+    let href = match link {
+        AssocItemLink::Anchor(Some(ref id)) => Some(format!("#{}", id)),
+        AssocItemLink::Anchor(None) => Some(format!("#{}.{}", item_type, name)),
+        AssocItemLink::GotoSource(did, provided_methods) => {
+            // We're creating a link from the implementation of an associated item to its
+            // declaration in the trait declaration.
+            let item_type = match item_type {
+                // For historical but not technical reasons, the item type of methods in
+                // trait declarations depends on whether the method is required (`TyMethod`) or
+                // provided (`Method`).
+                ItemType::Method | ItemType::TyMethod => {
+                    if provided_methods.contains(&name) {
+                        ItemType::Method
+                    } else {
+                        ItemType::TyMethod
+                    }
+                }
+                // For associated types and constants, no such distinction exists.
+                item_type => item_type,
+            };
+
+            match href(did.expect_def_id(), cx) {
+                Ok((url, ..)) => Some(format!("{}#{}.{}", url, item_type, name)),
+                // The link is broken since it points to an external crate that wasn't documented.
+                // Do not create any link in such case. This is better than falling back to a
+                // dummy anchor like `#{item_type}.{name}` representing the `id` of *this* impl item
+                // (that used to happen in older versions). Indeed, in most cases this dummy would
+                // coincide with the `id`. However, it would not always do so.
+                // In general, this dummy would be incorrect:
+                // If the type with the trait impl also had an inherent impl with an assoc. item of
+                // the *same* name as this impl item, the dummy would link to that one even though
+                // those two items are distinct!
+                // In this scenario, the actual `id` of this impl item would be
+                // `#{item_type}.{name}-{n}` for some number `n` (a disambiguator).
+                Err(HrefError::DocumentationNotBuilt) => None,
+                Err(_) => Some(format!("#{}.{}", item_type, name)),
+            }
+        }
+    };
+
+    // If there is no `href` for the reason explained above, simply do not render it which is valid:
+    // https://html.spec.whatwg.org/multipage/links.html#links-created-by-a-and-area-elements
+    href.map(|href| format!(" href=\"{}\"", href)).unwrap_or_default()
+}
+
+fn assoc_const(
+    w: &mut Buffer,
+    it: &clean::Item,
+    ty: &clean::Type,
+    default: Option<&clean::ConstantKind>,
+    link: AssocItemLink<'_>,
+    extra: &str,
+    cx: &Context<'_>,
+) {
+    write!(
+        w,
+        "{extra}{vis}const <a{href} class=\"constant\">{name}</a>: {ty}",
+        extra = extra,
+        vis = it.visibility.print_with_space(it.item_id, cx),
+        href = assoc_href_attr(it, link, cx),
+        name = it.name.as_ref().unwrap(),
+        ty = ty.print(cx),
+    );
+    if let Some(default) = default {
+        write!(w, " = ");
+
+        // FIXME: `.value()` uses `clean::utils::format_integer_with_underscore_sep` under the
+        //        hood which adds noisy underscores and a type suffix to number literals.
+        //        This hurts readability in this context especially when more complex expressions
+        //        are involved and it doesn't add much of value.
+        //        Find a way to print constants here without all that jazz.
+        write!(w, "{}", Escape(&default.value(cx.tcx()).unwrap_or_else(|| default.expr(cx.tcx()))));
+    }
+}
+
+fn assoc_type(
+    w: &mut Buffer,
+    it: &clean::Item,
+    generics: &clean::Generics,
+    bounds: &[clean::GenericBound],
+    default: Option<&clean::Type>,
+    link: AssocItemLink<'_>,
+    indent: usize,
+    cx: &Context<'_>,
+) {
+    write!(
+        w,
+        "{indent}type <a{href} class=\"associatedtype\">{name}</a>{generics}",
+        indent = " ".repeat(indent),
+        href = assoc_href_attr(it, link, cx),
+        name = it.name.as_ref().unwrap(),
+        generics = generics.print(cx),
+    );
+    if !bounds.is_empty() {
+        write!(w, ": {}", print_generic_bounds(bounds, cx))
+    }
+    write!(w, "{}", print_where_clause(generics, cx, indent, Ending::NoNewline));
+    if let Some(default) = default {
+        write!(w, " = {}", default.print(cx))
+    }
+}
+
+fn assoc_method(
+    w: &mut Buffer,
+    meth: &clean::Item,
+    g: &clean::Generics,
+    d: &clean::FnDecl,
+    link: AssocItemLink<'_>,
+    parent: ItemType,
+    cx: &Context<'_>,
+    render_mode: RenderMode,
+) {
+    let header = meth.fn_header(cx.tcx()).expect("Trying to get header from a non-function item");
+    let name = meth.name.as_ref().unwrap();
+    let vis = meth.visibility.print_with_space(meth.item_id, cx).to_string();
+    // FIXME: Once https://github.com/rust-lang/rust/issues/67792 is implemented, we can remove
+    // this condition.
+    let constness = match render_mode {
+        RenderMode::Normal => {
+            print_constness_with_space(&header.constness, meth.const_stability(cx.tcx()))
+        }
+        RenderMode::ForDeref { .. } => "",
+    };
+    let asyncness = header.asyncness.print_with_space();
+    let unsafety = header.unsafety.print_with_space();
+    let defaultness = print_default_space(meth.is_default());
+    let abi = print_abi_with_space(header.abi).to_string();
+    let href = assoc_href_attr(meth, link, cx);
+
+    // NOTE: `{:#}` does not print HTML formatting, `{}` does. So `g.print` can't be reused between the length calculation and `write!`.
+    let generics_len = format!("{:#}", g.print(cx)).len();
+    let mut header_len = "fn ".len()
+        + vis.len()
+        + constness.len()
+        + asyncness.len()
+        + unsafety.len()
+        + defaultness.len()
+        + abi.len()
+        + name.as_str().len()
+        + generics_len;
+
+    let (indent, indent_str, end_newline) = if parent == ItemType::Trait {
+        header_len += 4;
+        let indent_str = "    ";
+        render_attributes_in_pre(w, meth, indent_str);
+        (4, indent_str, Ending::NoNewline)
+    } else {
+        render_attributes_in_code(w, meth);
+        (0, "", Ending::Newline)
+    };
+    w.reserve(header_len + "<a href=\"\" class=\"fnname\">{".len() + "</a>".len());
+    write!(
+        w,
+        "{indent}{vis}{constness}{asyncness}{unsafety}{defaultness}{abi}fn <a{href} class=\"fnname\">{name}</a>\
+         {generics}{decl}{notable_traits}{where_clause}",
+        indent = indent_str,
+        vis = vis,
+        constness = constness,
+        asyncness = asyncness,
+        unsafety = unsafety,
+        defaultness = defaultness,
+        abi = abi,
+        href = href,
+        name = name,
+        generics = g.print(cx),
+        decl = d.full_print(header_len, indent, header.asyncness, cx),
+        notable_traits = notable_traits_decl(d, cx),
+        where_clause = print_where_clause(g, cx, indent, end_newline),
+    )
+}
+
+/// Writes a span containing the versions at which an item became stable and/or const-stable. For
+/// example, if the item became stable at 1.0.0, and const-stable at 1.45.0, this function would
+/// write a span containing "1.0.0 (const: 1.45.0)".
+///
+/// Returns `true` if a stability annotation was rendered.
+///
+/// Stability and const-stability are considered separately. If the item is unstable, no version
+/// will be written. If the item is const-unstable, "const: unstable" will be appended to the
+/// span, with a link to the tracking issue if present. If an item's stability or const-stability
+/// version matches the version of its enclosing item, that version will be omitted.
+///
+/// Note that it is possible for an unstable function to be const-stable. In that case, the span
+/// will include the const-stable version, but no stable version will be emitted, as a natural
+/// consequence of the above rules.
+fn render_stability_since_raw(
+    w: &mut Buffer,
+    ver: Option<Symbol>,
+    const_stability: Option<ConstStability>,
+    containing_ver: Option<Symbol>,
+    containing_const_ver: Option<Symbol>,
+) -> bool {
+    let stable_version = ver.filter(|inner| !inner.is_empty() && Some(*inner) != containing_ver);
+
+    let mut title = String::new();
+    let mut stability = String::new();
+
+    if let Some(ver) = stable_version {
+        stability.push_str(ver.as_str());
+        title.push_str(&format!("Stable since Rust version {}", ver));
+    }
+
+    let const_title_and_stability = match const_stability {
+        Some(ConstStability { level: StabilityLevel::Stable { since, .. }, .. })
+            if Some(since) != containing_const_ver =>
+        {
+            Some((format!("const since {}", since), format!("const: {}", since)))
+        }
+        Some(ConstStability { level: StabilityLevel::Unstable { issue, .. }, feature, .. }) => {
+            let unstable = if let Some(n) = issue {
+                format!(
+                    r#"<a href="https://github.com/rust-lang/rust/issues/{}" title="Tracking issue for {}">unstable</a>"#,
+                    n, feature
+                )
+            } else {
+                String::from("unstable")
+            };
+
+            Some((String::from("const unstable"), format!("const: {}", unstable)))
+        }
+        _ => None,
+    };
+
+    if let Some((const_title, const_stability)) = const_title_and_stability {
+        if !title.is_empty() {
+            title.push_str(&format!(", {}", const_title));
+        } else {
+            title.push_str(&const_title);
+        }
+
+        if !stability.is_empty() {
+            stability.push_str(&format!(" ({})", const_stability));
+        } else {
+            stability.push_str(&const_stability);
+        }
+    }
+
+    if !stability.is_empty() {
+        write!(w, r#"<span class="since" title="{}">{}</span>"#, title, stability);
+    }
+
+    !stability.is_empty()
+}
+
+fn render_assoc_item(
+    w: &mut Buffer,
+    item: &clean::Item,
+    link: AssocItemLink<'_>,
+    parent: ItemType,
+    cx: &Context<'_>,
+    render_mode: RenderMode,
+) {
+    match &*item.kind {
+        clean::StrippedItem(..) => {}
+        clean::TyMethodItem(m) => {
+            assoc_method(w, item, &m.generics, &m.decl, link, parent, cx, render_mode)
+        }
+        clean::MethodItem(m, _) => {
+            assoc_method(w, item, &m.generics, &m.decl, link, parent, cx, render_mode)
+        }
+        kind @ (clean::TyAssocConstItem(ty) | clean::AssocConstItem(ty, _)) => assoc_const(
+            w,
+            item,
+            ty,
+            match kind {
+                clean::TyAssocConstItem(_) => None,
+                clean::AssocConstItem(_, default) => Some(default),
+                _ => unreachable!(),
+            },
+            link,
+            if parent == ItemType::Trait { "    " } else { "" },
+            cx,
+        ),
+        clean::TyAssocTypeItem(ref generics, ref bounds) => assoc_type(
+            w,
+            item,
+            generics,
+            bounds,
+            None,
+            link,
+            if parent == ItemType::Trait { 4 } else { 0 },
+            cx,
+        ),
+        clean::AssocTypeItem(ref ty, ref bounds) => assoc_type(
+            w,
+            item,
+            &ty.generics,
+            bounds,
+            Some(ty.item_type.as_ref().unwrap_or(&ty.type_)),
+            link,
+            if parent == ItemType::Trait { 4 } else { 0 },
+            cx,
+        ),
+        _ => panic!("render_assoc_item called on non-associated-item"),
+    }
+}
+
+const ALLOWED_ATTRIBUTES: &[Symbol] =
+    &[sym::export_name, sym::link_section, sym::no_mangle, sym::repr, sym::non_exhaustive];
+
+fn attributes(it: &clean::Item) -> Vec<String> {
+    it.attrs
+        .other_attrs
+        .iter()
+        .filter_map(|attr| {
+            if ALLOWED_ATTRIBUTES.contains(&attr.name_or_empty()) {
+                Some(
+                    pprust::attribute_to_string(attr)
+                        .replace("\\\n", "")
+                        .replace('\n', "")
+                        .replace("  ", " "),
+                )
+            } else {
+                None
+            }
+        })
+        .collect()
+}
+
+// When an attribute is rendered inside a `<pre>` tag, it is formatted using
+// a whitespace prefix and newline.
+fn render_attributes_in_pre(w: &mut Buffer, it: &clean::Item, prefix: &str) {
+    for a in attributes(it) {
+        writeln!(w, "{}{}", prefix, a);
+    }
+}
+
+// When an attribute is rendered inside a <code> tag, it is formatted using
+// a div to produce a newline after it.
+fn render_attributes_in_code(w: &mut Buffer, it: &clean::Item) {
+    for a in attributes(it) {
+        write!(w, "<div class=\"code-attribute\">{}</div>", a);
+    }
+}
+
+#[derive(Copy, Clone)]
+enum AssocItemLink<'a> {
+    Anchor(Option<&'a str>),
+    GotoSource(ItemId, &'a FxHashSet<Symbol>),
+}
+
+impl<'a> AssocItemLink<'a> {
+    fn anchor(&self, id: &'a str) -> Self {
+        match *self {
+            AssocItemLink::Anchor(_) => AssocItemLink::Anchor(Some(id)),
+            ref other => *other,
+        }
+    }
+}
+
+fn render_assoc_items(
+    w: &mut Buffer,
+    cx: &mut Context<'_>,
+    containing_item: &clean::Item,
+    it: DefId,
+    what: AssocItemRender<'_>,
+) {
+    let mut derefs = FxHashSet::default();
+    derefs.insert(it);
+    render_assoc_items_inner(w, cx, containing_item, it, what, &mut derefs)
+}
+
+fn render_assoc_items_inner(
+    w: &mut Buffer,
+    cx: &mut Context<'_>,
+    containing_item: &clean::Item,
+    it: DefId,
+    what: AssocItemRender<'_>,
+    derefs: &mut FxHashSet<DefId>,
+) {
+    info!("Documenting associated items of {:?}", containing_item.name);
+    let shared = Rc::clone(&cx.shared);
+    let cache = &shared.cache;
+    let Some(v) = cache.impls.get(&it) else { return };
+    let (non_trait, traits): (Vec<_>, _) = v.iter().partition(|i| i.inner_impl().trait_.is_none());
+    if !non_trait.is_empty() {
+        let mut tmp_buf = Buffer::empty_from(w);
+        let (render_mode, id) = match what {
+            AssocItemRender::All => {
+                tmp_buf.write_str(
+                    "<h2 id=\"implementations\" class=\"small-section-header\">\
+                         Implementations\
+                         <a href=\"#implementations\" class=\"anchor\"></a>\
+                     </h2>",
+                );
+                (RenderMode::Normal, "implementations-list".to_owned())
+            }
+            AssocItemRender::DerefFor { trait_, type_, deref_mut_ } => {
+                let id =
+                    cx.derive_id(small_url_encode(format!("deref-methods-{:#}", type_.print(cx))));
+                if let Some(def_id) = type_.def_id(cx.cache()) {
+                    cx.deref_id_map.insert(def_id, id.clone());
+                }
+                write!(
+                    tmp_buf,
+                    "<h2 id=\"{id}\" class=\"small-section-header\">\
+                         <span>Methods from {trait_}&lt;Target = {type_}&gt;</span>\
+                         <a href=\"#{id}\" class=\"anchor\"></a>\
+                     </h2>",
+                    id = id,
+                    trait_ = trait_.print(cx),
+                    type_ = type_.print(cx),
+                );
+                (RenderMode::ForDeref { mut_: deref_mut_ }, cx.derive_id(id))
+            }
+        };
+        let mut impls_buf = Buffer::empty_from(w);
+        for i in &non_trait {
+            render_impl(
+                &mut impls_buf,
+                cx,
+                i,
+                containing_item,
+                AssocItemLink::Anchor(None),
+                render_mode,
+                None,
+                &[],
+                ImplRenderingParameters {
+                    show_def_docs: true,
+                    show_default_items: true,
+                    show_non_assoc_items: true,
+                    toggle_open_by_default: true,
+                },
+            );
+        }
+        if !impls_buf.is_empty() {
+            w.push_buffer(tmp_buf);
+            write!(w, "<div id=\"{}\">", id);
+            w.push_buffer(impls_buf);
+            w.write_str("</div>");
+        }
+    }
+
+    if !traits.is_empty() {
+        let deref_impl =
+            traits.iter().find(|t| t.trait_did() == cx.tcx().lang_items().deref_trait());
+        if let Some(impl_) = deref_impl {
+            let has_deref_mut =
+                traits.iter().any(|t| t.trait_did() == cx.tcx().lang_items().deref_mut_trait());
+            render_deref_methods(w, cx, impl_, containing_item, has_deref_mut, derefs);
+        }
+
+        // If we were already one level into rendering deref methods, we don't want to render
+        // anything after recursing into any further deref methods above.
+        if let AssocItemRender::DerefFor { .. } = what {
+            return;
+        }
+
+        let (synthetic, concrete): (Vec<&&Impl>, Vec<&&Impl>) =
+            traits.iter().partition(|t| t.inner_impl().kind.is_auto());
+        let (blanket_impl, concrete): (Vec<&&Impl>, _) =
+            concrete.into_iter().partition(|t| t.inner_impl().kind.is_blanket());
+
+        let mut impls = Buffer::empty_from(w);
+        render_impls(cx, &mut impls, &concrete, containing_item, true);
+        let impls = impls.into_inner();
+        if !impls.is_empty() {
+            write!(
+                w,
+                "<h2 id=\"trait-implementations\" class=\"small-section-header\">\
+                     Trait Implementations\
+                     <a href=\"#trait-implementations\" class=\"anchor\"></a>\
+                 </h2>\
+                 <div id=\"trait-implementations-list\">{}</div>",
+                impls
+            );
+        }
+
+        if !synthetic.is_empty() {
+            w.write_str(
+                "<h2 id=\"synthetic-implementations\" class=\"small-section-header\">\
+                     Auto Trait Implementations\
+                     <a href=\"#synthetic-implementations\" class=\"anchor\"></a>\
+                 </h2>\
+                 <div id=\"synthetic-implementations-list\">",
+            );
+            render_impls(cx, w, &synthetic, containing_item, false);
+            w.write_str("</div>");
+        }
+
+        if !blanket_impl.is_empty() {
+            w.write_str(
+                "<h2 id=\"blanket-implementations\" class=\"small-section-header\">\
+                     Blanket Implementations\
+                     <a href=\"#blanket-implementations\" class=\"anchor\"></a>\
+                 </h2>\
+                 <div id=\"blanket-implementations-list\">",
+            );
+            render_impls(cx, w, &blanket_impl, containing_item, false);
+            w.write_str("</div>");
+        }
+    }
+}
+
+fn render_deref_methods(
+    w: &mut Buffer,
+    cx: &mut Context<'_>,
+    impl_: &Impl,
+    container_item: &clean::Item,
+    deref_mut: bool,
+    derefs: &mut FxHashSet<DefId>,
+) {
+    let cache = cx.cache();
+    let deref_type = impl_.inner_impl().trait_.as_ref().unwrap();
+    let (target, real_target) = impl_
+        .inner_impl()
+        .items
+        .iter()
+        .find_map(|item| match *item.kind {
+            clean::AssocTypeItem(box ref t, _) => Some(match *t {
+                clean::Typedef { item_type: Some(ref type_), .. } => (type_, &t.type_),
+                _ => (&t.type_, &t.type_),
+            }),
+            _ => None,
+        })
+        .expect("Expected associated type binding");
+    debug!("Render deref methods for {:#?}, target {:#?}", impl_.inner_impl().for_, target);
+    let what =
+        AssocItemRender::DerefFor { trait_: deref_type, type_: real_target, deref_mut_: deref_mut };
+    if let Some(did) = target.def_id(cache) {
+        if let Some(type_did) = impl_.inner_impl().for_.def_id(cache) {
+            // `impl Deref<Target = S> for S`
+            if did == type_did || !derefs.insert(did) {
+                // Avoid infinite cycles
+                return;
+            }
+        }
+        render_assoc_items_inner(w, cx, container_item, did, what, derefs);
+    } else if let Some(prim) = target.primitive_type() {
+        if let Some(&did) = cache.primitive_locations.get(&prim) {
+            render_assoc_items_inner(w, cx, container_item, did, what, derefs);
+        }
+    }
+}
+
+fn should_render_item(item: &clean::Item, deref_mut_: bool, tcx: TyCtxt<'_>) -> bool {
+    let self_type_opt = match *item.kind {
+        clean::MethodItem(ref method, _) => method.decl.self_type(),
+        clean::TyMethodItem(ref method) => method.decl.self_type(),
+        _ => None,
+    };
+
+    if let Some(self_ty) = self_type_opt {
+        let (by_mut_ref, by_box, by_value) = match self_ty {
+            SelfTy::SelfBorrowed(_, mutability)
+            | SelfTy::SelfExplicit(clean::BorrowedRef { mutability, .. }) => {
+                (mutability == Mutability::Mut, false, false)
+            }
+            SelfTy::SelfExplicit(clean::Type::Path { path }) => {
+                (false, Some(path.def_id()) == tcx.lang_items().owned_box(), false)
+            }
+            SelfTy::SelfValue => (false, false, true),
+            _ => (false, false, false),
+        };
+
+        (deref_mut_ || !by_mut_ref) && !by_box && !by_value
+    } else {
+        false
+    }
+}
+
+fn notable_traits_decl(decl: &clean::FnDecl, cx: &Context<'_>) -> String {
+    let mut out = Buffer::html();
+
+    if let Some((did, ty)) = decl.output.as_return().and_then(|t| Some((t.def_id(cx.cache())?, t)))
+    {
+        if let Some(impls) = cx.cache().impls.get(&did) {
+            for i in impls {
+                let impl_ = i.inner_impl();
+                if !impl_.for_.without_borrowed_ref().is_same(ty.without_borrowed_ref(), cx.cache())
+                {
+                    // Two different types might have the same did,
+                    // without actually being the same.
+                    continue;
+                }
+                if let Some(trait_) = &impl_.trait_ {
+                    let trait_did = trait_.def_id();
+
+                    if cx.cache().traits.get(&trait_did).map_or(false, |t| t.is_notable) {
+                        if out.is_empty() {
+                            write!(
+                                &mut out,
+                                "<span class=\"notable\">Notable traits for {}</span>\
+                             <code class=\"content\">",
+                                impl_.for_.print(cx)
+                            );
+                        }
+
+                        //use the "where" class here to make it small
+                        write!(
+                            &mut out,
+                            "<span class=\"where fmt-newline\">{}</span>",
+                            impl_.print(false, cx)
+                        );
+                        for it in &impl_.items {
+                            if let clean::AssocTypeItem(ref tydef, ref _bounds) = *it.kind {
+                                out.push_str("<span class=\"where fmt-newline\">    ");
+                                let empty_set = FxHashSet::default();
+                                let src_link =
+                                    AssocItemLink::GotoSource(trait_did.into(), &empty_set);
+                                assoc_type(
+                                    &mut out,
+                                    it,
+                                    &tydef.generics,
+                                    &[], // intentionally leaving out bounds
+                                    Some(&tydef.type_),
+                                    src_link,
+                                    0,
+                                    cx,
+                                );
+                                out.push_str(";</span>");
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    if !out.is_empty() {
+        out.insert_str(
+            0,
+            "<span class=\"notable-traits\"><span class=\"notable-traits-tooltip\">ⓘ\
+            <span class=\"notable-traits-tooltiptext\"><span class=\"docblock\">",
+        );
+        out.push_str("</code></span></span></span></span>");
+    }
+
+    out.into_inner()
+}
+
+#[derive(Clone, Copy, Debug)]
+struct ImplRenderingParameters {
+    show_def_docs: bool,
+    show_default_items: bool,
+    /// Whether or not to show methods.
+    show_non_assoc_items: bool,
+    toggle_open_by_default: bool,
+}
+
+fn render_impl(
+    w: &mut Buffer,
+    cx: &mut Context<'_>,
+    i: &Impl,
+    parent: &clean::Item,
+    link: AssocItemLink<'_>,
+    render_mode: RenderMode,
+    use_absolute: Option<bool>,
+    aliases: &[String],
+    rendering_params: ImplRenderingParameters,
+) {
+    let shared = Rc::clone(&cx.shared);
+    let cache = &shared.cache;
+    let traits = &cache.traits;
+    let trait_ = i.trait_did().map(|did| &traits[&did]);
+    let mut close_tags = String::new();
+
+    // For trait implementations, the `interesting` output contains all methods that have doc
+    // comments, and the `boring` output contains all methods that do not. The distinction is
+    // used to allow hiding the boring methods.
+    // `containing_item` is used for rendering stability info. If the parent is a trait impl,
+    // `containing_item` will the grandparent, since trait impls can't have stability attached.
+    fn doc_impl_item(
+        boring: &mut Buffer,
+        interesting: &mut Buffer,
+        cx: &mut Context<'_>,
+        item: &clean::Item,
+        parent: &clean::Item,
+        containing_item: &clean::Item,
+        link: AssocItemLink<'_>,
+        render_mode: RenderMode,
+        is_default_item: bool,
+        trait_: Option<&clean::Trait>,
+        rendering_params: ImplRenderingParameters,
+    ) {
+        let item_type = item.type_();
+        let name = item.name.as_ref().unwrap();
+
+        let render_method_item = rendering_params.show_non_assoc_items
+            && match render_mode {
+                RenderMode::Normal => true,
+                RenderMode::ForDeref { mut_: deref_mut_ } => {
+                    should_render_item(item, deref_mut_, cx.tcx())
+                }
+            };
+
+        let in_trait_class = if trait_.is_some() { " trait-impl" } else { "" };
+
+        let mut doc_buffer = Buffer::empty_from(boring);
+        let mut info_buffer = Buffer::empty_from(boring);
+        let mut short_documented = true;
+
+        if render_method_item {
+            if !is_default_item {
+                if let Some(t) = trait_ {
+                    // The trait item may have been stripped so we might not
+                    // find any documentation or stability for it.
+                    if let Some(it) = t.items.iter().find(|i| i.name == item.name) {
+                        // We need the stability of the item from the trait
+                        // because impls can't have a stability.
+                        if item.doc_value().is_some() {
+                            document_item_info(&mut info_buffer, cx, it, Some(parent));
+                            document_full(&mut doc_buffer, item, cx, HeadingOffset::H5);
+                            short_documented = false;
+                        } else {
+                            // In case the item isn't documented,
+                            // provide short documentation from the trait.
+                            document_short(
+                                &mut doc_buffer,
+                                it,
+                                cx,
+                                link,
+                                parent,
+                                rendering_params.show_def_docs,
+                            );
+                        }
+                    }
+                } else {
+                    document_item_info(&mut info_buffer, cx, item, Some(parent));
+                    if rendering_params.show_def_docs {
+                        document_full(&mut doc_buffer, item, cx, HeadingOffset::H5);
+                        short_documented = false;
+                    }
+                }
+            } else {
+                document_short(
+                    &mut doc_buffer,
+                    item,
+                    cx,
+                    link,
+                    parent,
+                    rendering_params.show_def_docs,
+                );
+            }
+        }
+        let w = if short_documented && trait_.is_some() { interesting } else { boring };
+
+        let toggled = !doc_buffer.is_empty();
+        if toggled {
+            let method_toggle_class =
+                if item_type == ItemType::Method { " method-toggle" } else { "" };
+            write!(w, "<details class=\"rustdoc-toggle{}\" open><summary>", method_toggle_class);
+        }
+        match &*item.kind {
+            clean::MethodItem(..) | clean::TyMethodItem(_) => {
+                // Only render when the method is not static or we allow static methods
+                if render_method_item {
+                    let id = cx.derive_id(format!("{}.{}", item_type, name));
+                    let source_id = trait_
+                        .and_then(|trait_| {
+                            trait_.items.iter().find(|item| {
+                                item.name.map(|n| n.as_str().eq(name.as_str())).unwrap_or(false)
+                            })
+                        })
+                        .map(|item| format!("{}.{}", item.type_(), name));
+                    write!(
+                        w,
+                        "<section id=\"{}\" class=\"{}{} has-srclink\">",
+                        id, item_type, in_trait_class,
+                    );
+                    render_rightside(w, cx, item, containing_item, render_mode);
+                    if trait_.is_some() {
+                        // Anchors are only used on trait impls.
+                        write!(w, "<a href=\"#{}\" class=\"anchor\"></a>", id);
+                    }
+                    w.write_str("<h4 class=\"code-header\">");
+                    render_assoc_item(
+                        w,
+                        item,
+                        link.anchor(source_id.as_ref().unwrap_or(&id)),
+                        ItemType::Impl,
+                        cx,
+                        render_mode,
+                    );
+                    w.write_str("</h4>");
+                    w.write_str("</section>");
+                }
+            }
+            kind @ (clean::TyAssocConstItem(ty) | clean::AssocConstItem(ty, _)) => {
+                let source_id = format!("{}.{}", item_type, name);
+                let id = cx.derive_id(source_id.clone());
+                write!(
+                    w,
+                    "<section id=\"{}\" class=\"{}{} has-srclink\">",
+                    id, item_type, in_trait_class
+                );
+                render_rightside(w, cx, item, containing_item, render_mode);
+                if trait_.is_some() {
+                    // Anchors are only used on trait impls.
+                    write!(w, "<a href=\"#{}\" class=\"anchor\"></a>", id);
+                }
+                w.write_str("<h4 class=\"code-header\">");
+                assoc_const(
+                    w,
+                    item,
+                    ty,
+                    match kind {
+                        clean::TyAssocConstItem(_) => None,
+                        clean::AssocConstItem(_, default) => Some(default),
+                        _ => unreachable!(),
+                    },
+                    link.anchor(if trait_.is_some() { &source_id } else { &id }),
+                    "",
+                    cx,
+                );
+                w.write_str("</h4>");
+                w.write_str("</section>");
+            }
+            clean::TyAssocTypeItem(generics, bounds) => {
+                let source_id = format!("{}.{}", item_type, name);
+                let id = cx.derive_id(source_id.clone());
+                write!(w, "<section id=\"{}\" class=\"{}{}\">", id, item_type, in_trait_class);
+                if trait_.is_some() {
+                    // Anchors are only used on trait impls.
+                    write!(w, "<a href=\"#{}\" class=\"anchor\"></a>", id);
+                }
+                w.write_str("<h4 class=\"code-header\">");
+                assoc_type(
+                    w,
+                    item,
+                    generics,
+                    bounds,
+                    None,
+                    link.anchor(if trait_.is_some() { &source_id } else { &id }),
+                    0,
+                    cx,
+                );
+                w.write_str("</h4>");
+                w.write_str("</section>");
+            }
+            clean::AssocTypeItem(tydef, _bounds) => {
+                let source_id = format!("{}.{}", item_type, name);
+                let id = cx.derive_id(source_id.clone());
+                write!(
+                    w,
+                    "<section id=\"{}\" class=\"{}{} has-srclink\">",
+                    id, item_type, in_trait_class
+                );
+                if trait_.is_some() {
+                    // Anchors are only used on trait impls.
+                    write!(w, "<a href=\"#{}\" class=\"anchor\"></a>", id);
+                }
+                w.write_str("<h4 class=\"code-header\">");
+                assoc_type(
+                    w,
+                    item,
+                    &tydef.generics,
+                    &[], // intentionally leaving out bounds
+                    Some(tydef.item_type.as_ref().unwrap_or(&tydef.type_)),
+                    link.anchor(if trait_.is_some() { &source_id } else { &id }),
+                    0,
+                    cx,
+                );
+                w.write_str("</h4>");
+                w.write_str("</section>");
+            }
+            clean::StrippedItem(..) => return,
+            _ => panic!("can't make docs for trait item with name {:?}", item.name),
+        }
+
+        w.push_buffer(info_buffer);
+        if toggled {
+            w.write_str("</summary>");
+            w.push_buffer(doc_buffer);
+            w.push_str("</details>");
+        }
+    }
+
+    let mut impl_items = Buffer::empty_from(w);
+    let mut default_impl_items = Buffer::empty_from(w);
+
+    for trait_item in &i.inner_impl().items {
+        doc_impl_item(
+            &mut default_impl_items,
+            &mut impl_items,
+            cx,
+            trait_item,
+            if trait_.is_some() { &i.impl_item } else { parent },
+            parent,
+            link,
+            render_mode,
+            false,
+            trait_.map(|t| &t.trait_),
+            rendering_params,
+        );
+    }
+
+    fn render_default_items(
+        boring: &mut Buffer,
+        interesting: &mut Buffer,
+        cx: &mut Context<'_>,
+        t: &clean::Trait,
+        i: &clean::Impl,
+        parent: &clean::Item,
+        containing_item: &clean::Item,
+        render_mode: RenderMode,
+        rendering_params: ImplRenderingParameters,
+    ) {
+        for trait_item in &t.items {
+            let n = trait_item.name;
+            if i.items.iter().any(|m| m.name == n) {
+                continue;
+            }
+            let did = i.trait_.as_ref().unwrap().def_id();
+            let provided_methods = i.provided_trait_methods(cx.tcx());
+            let assoc_link = AssocItemLink::GotoSource(did.into(), &provided_methods);
+
+            doc_impl_item(
+                boring,
+                interesting,
+                cx,
+                trait_item,
+                parent,
+                containing_item,
+                assoc_link,
+                render_mode,
+                true,
+                Some(t),
+                rendering_params,
+            );
+        }
+    }
+
+    // If we've implemented a trait, then also emit documentation for all
+    // default items which weren't overridden in the implementation block.
+    // We don't emit documentation for default items if they appear in the
+    // Implementations on Foreign Types or Implementors sections.
+    if rendering_params.show_default_items {
+        if let Some(t) = trait_ {
+            render_default_items(
+                &mut default_impl_items,
+                &mut impl_items,
+                cx,
+                &t.trait_,
+                i.inner_impl(),
+                &i.impl_item,
+                parent,
+                render_mode,
+                rendering_params,
+            );
+        }
+    }
+    if render_mode == RenderMode::Normal {
+        let toggled = !(impl_items.is_empty() && default_impl_items.is_empty());
+        if toggled {
+            close_tags.insert_str(0, "</details>");
+            write!(
+                w,
+                "<details class=\"rustdoc-toggle implementors-toggle\"{}>",
+                if rendering_params.toggle_open_by_default { " open" } else { "" }
+            );
+            write!(w, "<summary>")
+        }
+        render_impl_summary(
+            w,
+            cx,
+            i,
+            parent,
+            parent,
+            rendering_params.show_def_docs,
+            use_absolute,
+            aliases,
+        );
+        if toggled {
+            write!(w, "</summary>")
+        }
+
+        if let Some(ref dox) = i.impl_item.collapsed_doc_value() {
+            if trait_.is_none() && i.inner_impl().items.is_empty() {
+                w.write_str(
+                    "<div class=\"item-info\">\
+                    <div class=\"stab empty-impl\">This impl block contains no items.</div>
+                </div>",
+                );
+            }
+            write!(
+                w,
+                "<div class=\"docblock\">{}</div>",
+                Markdown {
+                    content: &*dox,
+                    links: &i.impl_item.links(cx),
+                    ids: &mut cx.id_map,
+                    error_codes: cx.shared.codes,
+                    edition: cx.shared.edition(),
+                    playground: &cx.shared.playground,
+                    heading_offset: HeadingOffset::H4
+                }
+                .into_string()
+            );
+        }
+    }
+    if !default_impl_items.is_empty() || !impl_items.is_empty() {
+        w.write_str("<div class=\"impl-items\">");
+        w.push_buffer(default_impl_items);
+        w.push_buffer(impl_items);
+        close_tags.insert_str(0, "</div>");
+    }
+    w.write_str(&close_tags);
+}
+
+// Render the items that appear on the right side of methods, impls, and
+// associated types. For example "1.0.0 (const: 1.39.0) · source".
+fn render_rightside(
+    w: &mut Buffer,
+    cx: &Context<'_>,
+    item: &clean::Item,
+    containing_item: &clean::Item,
+    render_mode: RenderMode,
+) {
+    let tcx = cx.tcx();
+
+    // FIXME: Once https://github.com/rust-lang/rust/issues/67792 is implemented, we can remove
+    // this condition.
+    let (const_stability, const_stable_since) = match render_mode {
+        RenderMode::Normal => (item.const_stability(tcx), containing_item.const_stable_since(tcx)),
+        RenderMode::ForDeref { .. } => (None, None),
+    };
+
+    let mut rightside = Buffer::new();
+    let has_stability = render_stability_since_raw(
+        &mut rightside,
+        item.stable_since(tcx),
+        const_stability,
+        containing_item.stable_since(tcx),
+        const_stable_since,
+    );
+    let mut srclink = Buffer::empty_from(w);
+    write_srclink(cx, item, &mut srclink);
+    if has_stability && !srclink.is_empty() {
+        rightside.write_str(" · ");
+    }
+    rightside.push_buffer(srclink);
+    if !rightside.is_empty() {
+        write!(w, "<span class=\"rightside\">{}</span>", rightside.into_inner());
+    }
+}
+
+pub(crate) fn render_impl_summary(
+    w: &mut Buffer,
+    cx: &mut Context<'_>,
+    i: &Impl,
+    parent: &clean::Item,
+    containing_item: &clean::Item,
+    show_def_docs: bool,
+    use_absolute: Option<bool>,
+    // This argument is used to reference same type with different paths to avoid duplication
+    // in documentation pages for trait with automatic implementations like "Send" and "Sync".
+    aliases: &[String],
+) {
+    let id =
+        cx.derive_id(get_id_for_impl(&i.inner_impl().for_, i.inner_impl().trait_.as_ref(), cx));
+    let aliases = if aliases.is_empty() {
+        String::new()
+    } else {
+        format!(" data-aliases=\"{}\"", aliases.join(","))
+    };
+    write!(w, "<section id=\"{}\" class=\"impl has-srclink\"{}>", id, aliases);
+    render_rightside(w, cx, &i.impl_item, containing_item, RenderMode::Normal);
+    write!(w, "<a href=\"#{}\" class=\"anchor\"></a>", id);
+    write!(w, "<h3 class=\"code-header in-band\">");
+
+    if let Some(use_absolute) = use_absolute {
+        write!(w, "{}", i.inner_impl().print(use_absolute, cx));
+        if show_def_docs {
+            for it in &i.inner_impl().items {
+                if let clean::AssocTypeItem(ref tydef, ref _bounds) = *it.kind {
+                    w.write_str("<span class=\"where fmt-newline\">  ");
+                    assoc_type(
+                        w,
+                        it,
+                        &tydef.generics,
+                        &[], // intentionally leaving out bounds
+                        Some(&tydef.type_),
+                        AssocItemLink::Anchor(None),
+                        0,
+                        cx,
+                    );
+                    w.write_str(";</span>");
+                }
+            }
+        }
+    } else {
+        write!(w, "{}", i.inner_impl().print(false, cx));
+    }
+    write!(w, "</h3>");
+
+    let is_trait = i.inner_impl().trait_.is_some();
+    if is_trait {
+        if let Some(portability) = portability(&i.impl_item, Some(parent)) {
+            write!(w, "<span class=\"item-info\">{}</span>", portability);
+        }
+    }
+
+    w.write_str("</section>");
+}
+
+fn print_sidebar(cx: &Context<'_>, it: &clean::Item, buffer: &mut Buffer) {
+    if it.is_struct()
+        || it.is_trait()
+        || it.is_primitive()
+        || it.is_union()
+        || it.is_enum()
+        || it.is_mod()
+        || it.is_typedef()
+    {
+        write!(
+            buffer,
+            "<h2 class=\"location\"><a href=\"#\">{}{}</a></h2>",
+            match *it.kind {
+                clean::ModuleItem(..) =>
+                    if it.is_crate() {
+                        "Crate "
+                    } else {
+                        "Module "
+                    },
+                _ => "",
+            },
+            it.name.as_ref().unwrap()
+        );
+    }
+
+    buffer.write_str("<div class=\"sidebar-elems\">");
+    if it.is_crate() {
+        write!(buffer, "<div class=\"block\"><ul>");
+        if let Some(ref version) = cx.cache().crate_version {
+            write!(buffer, "<li class=\"version\">Version {}</li>", Escape(version));
+        }
+        write!(buffer, "<li><a id=\"all-types\" href=\"all.html\">All Items</a></li>");
+        buffer.write_str("</ul></div>");
+    }
+
+    match *it.kind {
+        clean::StructItem(ref s) => sidebar_struct(cx, buffer, it, s),
+        clean::TraitItem(ref t) => sidebar_trait(cx, buffer, it, t),
+        clean::PrimitiveItem(_) => sidebar_primitive(cx, buffer, it),
+        clean::UnionItem(ref u) => sidebar_union(cx, buffer, it, u),
+        clean::EnumItem(ref e) => sidebar_enum(cx, buffer, it, e),
+        clean::TypedefItem(_) => sidebar_typedef(cx, buffer, it),
+        clean::ModuleItem(ref m) => sidebar_module(buffer, &m.items),
+        clean::ForeignTypeItem => sidebar_foreign_type(cx, buffer, it),
+        _ => {}
+    }
+
+    // The sidebar is designed to display sibling functions, modules and
+    // other miscellaneous information. since there are lots of sibling
+    // items (and that causes quadratic growth in large modules),
+    // we refactor common parts into a shared JavaScript file per module.
+    // still, we don't move everything into JS because we want to preserve
+    // as much HTML as possible in order to allow non-JS-enabled browsers
+    // to navigate the documentation (though slightly inefficiently).
+
+    if !it.is_mod() {
+        let path: String = cx.current.iter().map(|s| s.as_str()).intersperse("::").collect();
+
+        write!(buffer, "<h2 class=\"location\"><a href=\"index.html\">In {}</a></h2>", path);
+    }
+
+    // Closes sidebar-elems div.
+    buffer.write_str("</div>");
+}
+
+fn get_next_url(used_links: &mut FxHashSet<String>, url: String) -> String {
+    if used_links.insert(url.clone()) {
+        return url;
+    }
+    let mut add = 1;
+    while !used_links.insert(format!("{}-{}", url, add)) {
+        add += 1;
+    }
+    format!("{}-{}", url, add)
+}
+
+struct SidebarLink {
+    name: Symbol,
+    url: String,
+}
+
+impl fmt::Display for SidebarLink {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "<a href=\"#{}\">{}</a>", self.url, self.name)
+    }
+}
+
+impl PartialEq for SidebarLink {
+    fn eq(&self, other: &Self) -> bool {
+        self.url == other.url
+    }
+}
+
+impl Eq for SidebarLink {}
+
+impl PartialOrd for SidebarLink {
+    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for SidebarLink {
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        self.url.cmp(&other.url)
+    }
+}
+
+fn get_methods(
+    i: &clean::Impl,
+    for_deref: bool,
+    used_links: &mut FxHashSet<String>,
+    deref_mut: bool,
+    tcx: TyCtxt<'_>,
+) -> Vec<SidebarLink> {
+    i.items
+        .iter()
+        .filter_map(|item| match item.name {
+            Some(name) if !name.is_empty() && item.is_method() => {
+                if !for_deref || should_render_item(item, deref_mut, tcx) {
+                    Some(SidebarLink {
+                        name,
+                        url: get_next_url(used_links, format!("{}.{}", ItemType::Method, name)),
+                    })
+                } else {
+                    None
+                }
+            }
+            _ => None,
+        })
+        .collect::<Vec<_>>()
+}
+
+fn get_associated_constants(
+    i: &clean::Impl,
+    used_links: &mut FxHashSet<String>,
+) -> Vec<SidebarLink> {
+    i.items
+        .iter()
+        .filter_map(|item| match item.name {
+            Some(name) if !name.is_empty() && item.is_associated_const() => Some(SidebarLink {
+                name,
+                url: get_next_url(used_links, format!("{}.{}", ItemType::AssocConst, name)),
+            }),
+            _ => None,
+        })
+        .collect::<Vec<_>>()
+}
+
+// The point is to url encode any potential character from a type with genericity.
+fn small_url_encode(s: String) -> String {
+    let mut st = String::new();
+    let mut last_match = 0;
+    for (idx, c) in s.char_indices() {
+        let escaped = match c {
+            '<' => "%3C",
+            '>' => "%3E",
+            ' ' => "%20",
+            '?' => "%3F",
+            '\'' => "%27",
+            '&' => "%26",
+            ',' => "%2C",
+            ':' => "%3A",
+            ';' => "%3B",
+            '[' => "%5B",
+            ']' => "%5D",
+            '"' => "%22",
+            _ => continue,
+        };
+
+        st += &s[last_match..idx];
+        st += escaped;
+        // NOTE: we only expect single byte characters here - which is fine as long as we
+        // only match single byte characters
+        last_match = idx + 1;
+    }
+
+    if last_match != 0 {
+        st += &s[last_match..];
+        st
+    } else {
+        s
+    }
+}
+
+fn sidebar_assoc_items(cx: &Context<'_>, out: &mut Buffer, it: &clean::Item) {
+    let did = it.item_id.expect_def_id();
+    let cache = cx.cache();
+
+    if let Some(v) = cache.impls.get(&did) {
+        let mut used_links = FxHashSet::default();
+        let mut id_map = IdMap::new();
+
+        {
+            let used_links_bor = &mut used_links;
+            let mut assoc_consts = v
+                .iter()
+                .filter(|i| i.inner_impl().trait_.is_none())
+                .flat_map(|i| get_associated_constants(i.inner_impl(), used_links_bor))
+                .collect::<Vec<_>>();
+            if !assoc_consts.is_empty() {
+                // We want links' order to be reproducible so we don't use unstable sort.
+                assoc_consts.sort();
+
+                print_sidebar_block(
+                    out,
+                    "implementations",
+                    "Associated Constants",
+                    assoc_consts.iter(),
+                );
+            }
+            let mut methods = v
+                .iter()
+                .filter(|i| i.inner_impl().trait_.is_none())
+                .flat_map(|i| get_methods(i.inner_impl(), false, used_links_bor, false, cx.tcx()))
+                .collect::<Vec<_>>();
+            if !methods.is_empty() {
+                // We want links' order to be reproducible so we don't use unstable sort.
+                methods.sort();
+
+                print_sidebar_block(out, "implementations", "Methods", methods.iter());
+            }
+        }
+
+        if v.iter().any(|i| i.inner_impl().trait_.is_some()) {
+            if let Some(impl_) =
+                v.iter().find(|i| i.trait_did() == cx.tcx().lang_items().deref_trait())
+            {
+                let mut derefs = FxHashSet::default();
+                derefs.insert(did);
+                sidebar_deref_methods(cx, out, impl_, v, &mut derefs);
+            }
+
+            let format_impls = |impls: Vec<&Impl>, id_map: &mut IdMap| {
+                let mut links = FxHashSet::default();
+
+                let mut ret = impls
+                    .iter()
+                    .filter_map(|it| {
+                        let trait_ = it.inner_impl().trait_.as_ref()?;
+                        let encoded =
+                            id_map.derive(get_id_for_impl(&it.inner_impl().for_, Some(trait_), cx));
+
+                        let i_display = format!("{:#}", trait_.print(cx));
+                        let out = Escape(&i_display);
+                        let prefix = match it.inner_impl().polarity {
+                            ty::ImplPolarity::Positive | ty::ImplPolarity::Reservation => "",
+                            ty::ImplPolarity::Negative => "!",
+                        };
+                        let generated = format!("<a href=\"#{}\">{}{}</a>", encoded, prefix, out);
+                        if links.insert(generated.clone()) { Some(generated) } else { None }
+                    })
+                    .collect::<Vec<String>>();
+                ret.sort();
+                ret
+            };
+
+            let (synthetic, concrete): (Vec<&Impl>, Vec<&Impl>) =
+                v.iter().partition::<Vec<_>, _>(|i| i.inner_impl().kind.is_auto());
+            let (blanket_impl, concrete): (Vec<&Impl>, Vec<&Impl>) =
+                concrete.into_iter().partition::<Vec<_>, _>(|i| i.inner_impl().kind.is_blanket());
+
+            let concrete_format = format_impls(concrete, &mut id_map);
+            let synthetic_format = format_impls(synthetic, &mut id_map);
+            let blanket_format = format_impls(blanket_impl, &mut id_map);
+
+            if !concrete_format.is_empty() {
+                print_sidebar_block(
+                    out,
+                    "trait-implementations",
+                    "Trait Implementations",
+                    concrete_format.iter(),
+                );
+            }
+
+            if !synthetic_format.is_empty() {
+                print_sidebar_block(
+                    out,
+                    "synthetic-implementations",
+                    "Auto Trait Implementations",
+                    synthetic_format.iter(),
+                );
+            }
+
+            if !blanket_format.is_empty() {
+                print_sidebar_block(
+                    out,
+                    "blanket-implementations",
+                    "Blanket Implementations",
+                    blanket_format.iter(),
+                );
+            }
+        }
+    }
+}
+
+fn sidebar_deref_methods(
+    cx: &Context<'_>,
+    out: &mut Buffer,
+    impl_: &Impl,
+    v: &[Impl],
+    derefs: &mut FxHashSet<DefId>,
+) {
+    let c = cx.cache();
+
+    debug!("found Deref: {:?}", impl_);
+    if let Some((target, real_target)) =
+        impl_.inner_impl().items.iter().find_map(|item| match *item.kind {
+            clean::AssocTypeItem(box ref t, _) => Some(match *t {
+                clean::Typedef { item_type: Some(ref type_), .. } => (type_, &t.type_),
+                _ => (&t.type_, &t.type_),
+            }),
+            _ => None,
+        })
+    {
+        debug!("found target, real_target: {:?} {:?}", target, real_target);
+        if let Some(did) = target.def_id(c) {
+            if let Some(type_did) = impl_.inner_impl().for_.def_id(c) {
+                // `impl Deref<Target = S> for S`
+                if did == type_did || !derefs.insert(did) {
+                    // Avoid infinite cycles
+                    return;
+                }
+            }
+        }
+        let deref_mut = v.iter().any(|i| i.trait_did() == cx.tcx().lang_items().deref_mut_trait());
+        let inner_impl = target
+            .def_id(c)
+            .or_else(|| {
+                target.primitive_type().and_then(|prim| c.primitive_locations.get(&prim).cloned())
+            })
+            .and_then(|did| c.impls.get(&did));
+        if let Some(impls) = inner_impl {
+            debug!("found inner_impl: {:?}", impls);
+            let mut used_links = FxHashSet::default();
+            let mut ret = impls
+                .iter()
+                .filter(|i| i.inner_impl().trait_.is_none())
+                .flat_map(|i| {
+                    get_methods(i.inner_impl(), true, &mut used_links, deref_mut, cx.tcx())
+                })
+                .collect::<Vec<_>>();
+            if !ret.is_empty() {
+                let id = if let Some(target_def_id) = real_target.def_id(c) {
+                    cx.deref_id_map.get(&target_def_id).expect("Deref section without derived id")
+                } else {
+                    "deref-methods"
+                };
+                let title = format!(
+                    "Methods from {}&lt;Target={}&gt;",
+                    Escape(&format!("{:#}", impl_.inner_impl().trait_.as_ref().unwrap().print(cx))),
+                    Escape(&format!("{:#}", real_target.print(cx))),
+                );
+                // We want links' order to be reproducible so we don't use unstable sort.
+                ret.sort();
+                print_sidebar_block(out, id, &title, ret.iter());
+            }
+        }
+
+        // Recurse into any further impls that might exist for `target`
+        if let Some(target_did) = target.def_id(c) {
+            if let Some(target_impls) = c.impls.get(&target_did) {
+                if let Some(target_deref_impl) = target_impls.iter().find(|i| {
+                    i.inner_impl()
+                        .trait_
+                        .as_ref()
+                        .map(|t| Some(t.def_id()) == cx.tcx().lang_items().deref_trait())
+                        .unwrap_or(false)
+                }) {
+                    sidebar_deref_methods(cx, out, target_deref_impl, target_impls, derefs);
+                }
+            }
+        }
+    }
+}
+
+fn sidebar_struct(cx: &Context<'_>, buf: &mut Buffer, it: &clean::Item, s: &clean::Struct) {
+    let mut sidebar = Buffer::new();
+    let fields = get_struct_fields_name(&s.fields);
+
+    if !fields.is_empty() {
+        match s.struct_type {
+            CtorKind::Fictive => {
+                print_sidebar_block(&mut sidebar, "fields", "Fields", fields.iter());
+            }
+            CtorKind::Fn => print_sidebar_title(&mut sidebar, "fields", "Tuple Fields"),
+            CtorKind::Const => {}
+        }
+    }
+
+    sidebar_assoc_items(cx, &mut sidebar, it);
+
+    if !sidebar.is_empty() {
+        write!(buf, "<section>{}</section>", sidebar.into_inner());
+    }
+}
+
+fn get_id_for_impl(for_: &clean::Type, trait_: Option<&clean::Path>, cx: &Context<'_>) -> String {
+    match trait_ {
+        Some(t) => small_url_encode(format!("impl-{:#}-for-{:#}", t.print(cx), for_.print(cx))),
+        None => small_url_encode(format!("impl-{:#}", for_.print(cx))),
+    }
+}
+
+fn extract_for_impl_name(item: &clean::Item, cx: &Context<'_>) -> Option<(String, String)> {
+    match *item.kind {
+        clean::ItemKind::ImplItem(ref i) => {
+            i.trait_.as_ref().map(|trait_| {
+                // Alternative format produces no URLs,
+                // so this parameter does nothing.
+                (format!("{:#}", i.for_.print(cx)), get_id_for_impl(&i.for_, Some(trait_), cx))
+            })
+        }
+        _ => None,
+    }
+}
+
+/// Don't call this function directly!!! Use `print_sidebar_title` or `print_sidebar_block` instead!
+fn print_sidebar_title_inner(buf: &mut Buffer, id: &str, title: &str) {
+    write!(
+        buf,
+        "<h3 class=\"sidebar-title\">\
+             <a href=\"#{}\">{}</a>\
+         </h3>",
+        id, title
+    );
+}
+
+fn print_sidebar_title(buf: &mut Buffer, id: &str, title: &str) {
+    buf.push_str("<div class=\"block\">");
+    print_sidebar_title_inner(buf, id, title);
+    buf.push_str("</div>");
+}
+
+fn print_sidebar_block(
+    buf: &mut Buffer,
+    id: &str,
+    title: &str,
+    items: impl Iterator<Item = impl fmt::Display>,
+) {
+    buf.push_str("<div class=\"block\">");
+    print_sidebar_title_inner(buf, id, title);
+    buf.push_str("<ul>");
+    for item in items {
+        write!(buf, "<li>{}</li>", item);
+    }
+    buf.push_str("</ul></div>");
+}
+
+fn sidebar_trait(cx: &Context<'_>, buf: &mut Buffer, it: &clean::Item, t: &clean::Trait) {
+    buf.write_str("<section>");
+
+    fn print_sidebar_section(
+        out: &mut Buffer,
+        items: &[clean::Item],
+        id: &str,
+        title: &str,
+        filter: impl Fn(&clean::Item) -> bool,
+        mapper: impl Fn(&str) -> String,
+    ) {
+        let mut items: Vec<&str> = items
+            .iter()
+            .filter_map(|m| match m.name {
+                Some(ref name) if filter(m) => Some(name.as_str()),
+                _ => None,
+            })
+            .collect::<Vec<_>>();
+
+        if !items.is_empty() {
+            items.sort_unstable();
+            print_sidebar_block(out, id, title, items.into_iter().map(mapper));
+        }
+    }
+
+    print_sidebar_section(
+        buf,
+        &t.items,
+        "required-associated-types",
+        "Required Associated Types",
+        |m| m.is_ty_associated_type(),
+        |sym| format!("<a href=\"#{1}.{0}\">{0}</a>", sym, ItemType::AssocType),
+    );
+
+    print_sidebar_section(
+        buf,
+        &t.items,
+        "provided-associated-types",
+        "Provided Associated Types",
+        |m| m.is_associated_type(),
+        |sym| format!("<a href=\"#{1}.{0}\">{0}</a>", sym, ItemType::AssocType),
+    );
+
+    print_sidebar_section(
+        buf,
+        &t.items,
+        "required-associated-consts",
+        "Required Associated Constants",
+        |m| m.is_ty_associated_const(),
+        |sym| format!("<a href=\"#{1}.{0}\">{0}</a>", sym, ItemType::AssocConst),
+    );
+
+    print_sidebar_section(
+        buf,
+        &t.items,
+        "provided-associated-consts",
+        "Provided Associated Constants",
+        |m| m.is_associated_const(),
+        |sym| format!("<a href=\"#{1}.{0}\">{0}</a>", sym, ItemType::AssocConst),
+    );
+
+    print_sidebar_section(
+        buf,
+        &t.items,
+        "required-methods",
+        "Required Methods",
+        |m| m.is_ty_method(),
+        |sym| format!("<a href=\"#{1}.{0}\">{0}</a>", sym, ItemType::TyMethod),
+    );
+
+    print_sidebar_section(
+        buf,
+        &t.items,
+        "provided-methods",
+        "Provided Methods",
+        |m| m.is_method(),
+        |sym| format!("<a href=\"#{1}.{0}\">{0}</a>", sym, ItemType::Method),
+    );
+
+    if let Some(implementors) = cx.cache().implementors.get(&it.item_id.expect_def_id()) {
+        let mut res = implementors
+            .iter()
+            .filter(|i| !i.is_on_local_type(cx))
+            .filter_map(|i| extract_for_impl_name(&i.impl_item, cx))
+            .collect::<Vec<_>>();
+
+        if !res.is_empty() {
+            res.sort();
+            print_sidebar_block(
+                buf,
+                "foreign-impls",
+                "Implementations on Foreign Types",
+                res.iter().map(|(name, id)| format!("<a href=\"#{}\">{}</a>", id, Escape(name))),
+            );
+        }
+    }
+
+    sidebar_assoc_items(cx, buf, it);
+
+    print_sidebar_title(buf, "implementors", "Implementors");
+    if t.is_auto(cx.tcx()) {
+        print_sidebar_title(buf, "synthetic-implementors", "Auto Implementors");
+    }
+
+    buf.push_str("</section>")
+}
+
+fn sidebar_primitive(cx: &Context<'_>, buf: &mut Buffer, it: &clean::Item) {
+    let mut sidebar = Buffer::new();
+    sidebar_assoc_items(cx, &mut sidebar, it);
+
+    if !sidebar.is_empty() {
+        write!(buf, "<section>{}</section>", sidebar.into_inner());
+    }
+}
+
+fn sidebar_typedef(cx: &Context<'_>, buf: &mut Buffer, it: &clean::Item) {
+    let mut sidebar = Buffer::new();
+    sidebar_assoc_items(cx, &mut sidebar, it);
+
+    if !sidebar.is_empty() {
+        write!(buf, "<section>{}</section>", sidebar.into_inner());
+    }
+}
+
+fn get_struct_fields_name(fields: &[clean::Item]) -> Vec<String> {
+    let mut fields = fields
+        .iter()
+        .filter(|f| matches!(*f.kind, clean::StructFieldItem(..)))
+        .filter_map(|f| {
+            f.name.map(|name| format!("<a href=\"#structfield.{name}\">{name}</a>", name = name))
+        })
+        .collect::<Vec<_>>();
+    fields.sort();
+    fields
+}
+
+fn sidebar_union(cx: &Context<'_>, buf: &mut Buffer, it: &clean::Item, u: &clean::Union) {
+    let mut sidebar = Buffer::new();
+    let fields = get_struct_fields_name(&u.fields);
+
+    if !fields.is_empty() {
+        print_sidebar_block(&mut sidebar, "fields", "Fields", fields.iter());
+    }
+
+    sidebar_assoc_items(cx, &mut sidebar, it);
+
+    if !sidebar.is_empty() {
+        write!(buf, "<section>{}</section>", sidebar.into_inner());
+    }
+}
+
+fn sidebar_enum(cx: &Context<'_>, buf: &mut Buffer, it: &clean::Item, e: &clean::Enum) {
+    let mut sidebar = Buffer::new();
+
+    let mut variants = e
+        .variants()
+        .filter_map(|v| {
+            v.name
+                .as_ref()
+                .map(|name| format!("<a href=\"#variant.{name}\">{name}</a>", name = name))
+        })
+        .collect::<Vec<_>>();
+    if !variants.is_empty() {
+        variants.sort_unstable();
+        print_sidebar_block(&mut sidebar, "variants", "Variants", variants.iter());
+    }
+
+    sidebar_assoc_items(cx, &mut sidebar, it);
+
+    if !sidebar.is_empty() {
+        write!(buf, "<section>{}</section>", sidebar.into_inner());
+    }
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+enum ItemSection {
+    Reexports,
+    PrimitiveTypes,
+    Modules,
+    Macros,
+    Structs,
+    Enums,
+    Constants,
+    Statics,
+    Traits,
+    Functions,
+    TypeDefinitions,
+    Unions,
+    Implementations,
+    TypeMethods,
+    Methods,
+    StructFields,
+    Variants,
+    AssociatedTypes,
+    AssociatedConstants,
+    ForeignTypes,
+    Keywords,
+    OpaqueTypes,
+    AttributeMacros,
+    DeriveMacros,
+    TraitAliases,
+}
+
+impl ItemSection {
+    const ALL: &'static [Self] = {
+        use ItemSection::*;
+        // NOTE: The order here affects the order in the UI.
+        &[
+            Reexports,
+            PrimitiveTypes,
+            Modules,
+            Macros,
+            Structs,
+            Enums,
+            Constants,
+            Statics,
+            Traits,
+            Functions,
+            TypeDefinitions,
+            Unions,
+            Implementations,
+            TypeMethods,
+            Methods,
+            StructFields,
+            Variants,
+            AssociatedTypes,
+            AssociatedConstants,
+            ForeignTypes,
+            Keywords,
+            OpaqueTypes,
+            AttributeMacros,
+            DeriveMacros,
+            TraitAliases,
+        ]
+    };
+
+    fn id(self) -> &'static str {
+        match self {
+            Self::Reexports => "reexports",
+            Self::Modules => "modules",
+            Self::Structs => "structs",
+            Self::Unions => "unions",
+            Self::Enums => "enums",
+            Self::Functions => "functions",
+            Self::TypeDefinitions => "types",
+            Self::Statics => "statics",
+            Self::Constants => "constants",
+            Self::Traits => "traits",
+            Self::Implementations => "impls",
+            Self::TypeMethods => "tymethods",
+            Self::Methods => "methods",
+            Self::StructFields => "fields",
+            Self::Variants => "variants",
+            Self::Macros => "macros",
+            Self::PrimitiveTypes => "primitives",
+            Self::AssociatedTypes => "associated-types",
+            Self::AssociatedConstants => "associated-consts",
+            Self::ForeignTypes => "foreign-types",
+            Self::Keywords => "keywords",
+            Self::OpaqueTypes => "opaque-types",
+            Self::AttributeMacros => "attributes",
+            Self::DeriveMacros => "derives",
+            Self::TraitAliases => "trait-aliases",
+        }
+    }
+
+    fn name(self) -> &'static str {
+        match self {
+            Self::Reexports => "Re-exports",
+            Self::Modules => "Modules",
+            Self::Structs => "Structs",
+            Self::Unions => "Unions",
+            Self::Enums => "Enums",
+            Self::Functions => "Functions",
+            Self::TypeDefinitions => "Type Definitions",
+            Self::Statics => "Statics",
+            Self::Constants => "Constants",
+            Self::Traits => "Traits",
+            Self::Implementations => "Implementations",
+            Self::TypeMethods => "Type Methods",
+            Self::Methods => "Methods",
+            Self::StructFields => "Struct Fields",
+            Self::Variants => "Variants",
+            Self::Macros => "Macros",
+            Self::PrimitiveTypes => "Primitive Types",
+            Self::AssociatedTypes => "Associated Types",
+            Self::AssociatedConstants => "Associated Constants",
+            Self::ForeignTypes => "Foreign Types",
+            Self::Keywords => "Keywords",
+            Self::OpaqueTypes => "Opaque Types",
+            Self::AttributeMacros => "Attribute Macros",
+            Self::DeriveMacros => "Derive Macros",
+            Self::TraitAliases => "Trait Aliases",
+        }
+    }
+}
+
+fn item_ty_to_section(ty: ItemType) -> ItemSection {
+    match ty {
+        ItemType::ExternCrate | ItemType::Import => ItemSection::Reexports,
+        ItemType::Module => ItemSection::Modules,
+        ItemType::Struct => ItemSection::Structs,
+        ItemType::Union => ItemSection::Unions,
+        ItemType::Enum => ItemSection::Enums,
+        ItemType::Function => ItemSection::Functions,
+        ItemType::Typedef => ItemSection::TypeDefinitions,
+        ItemType::Static => ItemSection::Statics,
+        ItemType::Constant => ItemSection::Constants,
+        ItemType::Trait => ItemSection::Traits,
+        ItemType::Impl => ItemSection::Implementations,
+        ItemType::TyMethod => ItemSection::TypeMethods,
+        ItemType::Method => ItemSection::Methods,
+        ItemType::StructField => ItemSection::StructFields,
+        ItemType::Variant => ItemSection::Variants,
+        ItemType::Macro => ItemSection::Macros,
+        ItemType::Primitive => ItemSection::PrimitiveTypes,
+        ItemType::AssocType => ItemSection::AssociatedTypes,
+        ItemType::AssocConst => ItemSection::AssociatedConstants,
+        ItemType::ForeignType => ItemSection::ForeignTypes,
+        ItemType::Keyword => ItemSection::Keywords,
+        ItemType::OpaqueTy => ItemSection::OpaqueTypes,
+        ItemType::ProcAttribute => ItemSection::AttributeMacros,
+        ItemType::ProcDerive => ItemSection::DeriveMacros,
+        ItemType::TraitAlias => ItemSection::TraitAliases,
+    }
+}
+
+fn sidebar_module(buf: &mut Buffer, items: &[clean::Item]) {
+    use std::fmt::Write as _;
+
+    let mut sidebar = String::new();
+
+    let item_sections_in_use: FxHashSet<_> = items
+        .iter()
+        .filter(|it| {
+            !it.is_stripped()
+                && it
+                    .name
+                    .or_else(|| {
+                        if let clean::ImportItem(ref i) = *it.kind &&
+                            let clean::ImportKind::Simple(s) = i.kind { Some(s) } else { None }
+                    })
+                    .is_some()
+        })
+        .map(|it| item_ty_to_section(it.type_()))
+        .collect();
+    for &sec in ItemSection::ALL.iter().filter(|sec| item_sections_in_use.contains(sec)) {
+        let _ = write!(sidebar, "<li><a href=\"#{}\">{}</a></li>", sec.id(), sec.name());
+    }
+
+    if !sidebar.is_empty() {
+        write!(
+            buf,
+            "<section>\
+                 <div class=\"block\">\
+                     <ul>{}</ul>\
+                 </div>\
+             </section>",
+            sidebar
+        );
+    }
+}
+
+fn sidebar_foreign_type(cx: &Context<'_>, buf: &mut Buffer, it: &clean::Item) {
+    let mut sidebar = Buffer::new();
+    sidebar_assoc_items(cx, &mut sidebar, it);
+
+    if !sidebar.is_empty() {
+        write!(buf, "<section>{}</section>", sidebar.into_inner());
+    }
+}
+
+pub(crate) const BASIC_KEYWORDS: &str = "rust, rustlang, rust-lang";
+
+/// Returns a list of all paths used in the type.
+/// This is used to help deduplicate imported impls
+/// for reexported types. If any of the contained
+/// types are re-exported, we don't use the corresponding
+/// entry from the js file, as inlining will have already
+/// picked up the impl
+fn collect_paths_for_type(first_ty: clean::Type, cache: &Cache) -> Vec<String> {
+    let mut out = Vec::new();
+    let mut visited = FxHashSet::default();
+    let mut work = VecDeque::new();
+
+    let mut process_path = |did: DefId| {
+        let get_extern = || cache.external_paths.get(&did).map(|s| s.0.clone());
+        let fqp = cache.exact_paths.get(&did).cloned().or_else(get_extern);
+
+        if let Some(path) = fqp {
+            out.push(join_with_double_colon(&path));
+        }
+    };
+
+    work.push_back(first_ty);
+
+    while let Some(ty) = work.pop_front() {
+        if !visited.insert(ty.clone()) {
+            continue;
+        }
+
+        match ty {
+            clean::Type::Path { path } => process_path(path.def_id()),
+            clean::Type::Tuple(tys) => {
+                work.extend(tys.into_iter());
+            }
+            clean::Type::Slice(ty) => {
+                work.push_back(*ty);
+            }
+            clean::Type::Array(ty, _) => {
+                work.push_back(*ty);
+            }
+            clean::Type::RawPointer(_, ty) => {
+                work.push_back(*ty);
+            }
+            clean::Type::BorrowedRef { type_, .. } => {
+                work.push_back(*type_);
+            }
+            clean::Type::QPath { self_type, trait_, .. } => {
+                work.push_back(*self_type);
+                process_path(trait_.def_id());
+            }
+            _ => {}
+        }
+    }
+    out
+}
+
+const MAX_FULL_EXAMPLES: usize = 5;
+const NUM_VISIBLE_LINES: usize = 10;
+
+/// Generates the HTML for example call locations generated via the --scrape-examples flag.
+fn render_call_locations(w: &mut Buffer, cx: &mut Context<'_>, item: &clean::Item) {
+    let tcx = cx.tcx();
+    let def_id = item.item_id.expect_def_id();
+    let key = tcx.def_path_hash(def_id);
+    let Some(call_locations) = cx.shared.call_locations.get(&key) else { return };
+
+    // Generate a unique ID so users can link to this section for a given method
+    let id = cx.id_map.derive("scraped-examples");
+    write!(
+        w,
+        "<div class=\"docblock scraped-example-list\">\
+          <span></span>\
+          <h5 id=\"{id}\">\
+             <a href=\"#{id}\">Examples found in repository</a>\
+             <a class=\"scrape-help\" href=\"{root_path}scrape-examples-help.html\">?</a>\
+          </h5>",
+        root_path = cx.root_path(),
+        id = id
+    );
+
+    // Create a URL to a particular location in a reverse-dependency's source file
+    let link_to_loc = |call_data: &CallData, loc: &CallLocation| -> (String, String) {
+        let (line_lo, line_hi) = loc.call_expr.line_span;
+        let (anchor, title) = if line_lo == line_hi {
+            ((line_lo + 1).to_string(), format!("line {}", line_lo + 1))
+        } else {
+            (
+                format!("{}-{}", line_lo + 1, line_hi + 1),
+                format!("lines {}-{}", line_lo + 1, line_hi + 1),
+            )
+        };
+        let url = format!("{}{}#{}", cx.root_path(), call_data.url, anchor);
+        (url, title)
+    };
+
+    // Generate the HTML for a single example, being the title and code block
+    let write_example = |w: &mut Buffer, (path, call_data): (&PathBuf, &CallData)| -> bool {
+        let contents = match fs::read_to_string(&path) {
+            Ok(contents) => contents,
+            Err(err) => {
+                let span = item.span(tcx).inner();
+                tcx.sess
+                    .span_err(span, &format!("failed to read file {}: {}", path.display(), err));
+                return false;
+            }
+        };
+
+        // To reduce file sizes, we only want to embed the source code needed to understand the example, not
+        // the entire file. So we find the smallest byte range that covers all items enclosing examples.
+        assert!(!call_data.locations.is_empty());
+        let min_loc =
+            call_data.locations.iter().min_by_key(|loc| loc.enclosing_item.byte_span.0).unwrap();
+        let byte_min = min_loc.enclosing_item.byte_span.0;
+        let line_min = min_loc.enclosing_item.line_span.0;
+        let max_loc =
+            call_data.locations.iter().max_by_key(|loc| loc.enclosing_item.byte_span.1).unwrap();
+        let byte_max = max_loc.enclosing_item.byte_span.1;
+        let line_max = max_loc.enclosing_item.line_span.1;
+
+        // The output code is limited to that byte range.
+        let contents_subset = &contents[(byte_min as usize)..(byte_max as usize)];
+
+        // The call locations need to be updated to reflect that the size of the program has changed.
+        // Specifically, the ranges are all subtracted by `byte_min` since that's the new zero point.
+        let (mut byte_ranges, line_ranges): (Vec<_>, Vec<_>) = call_data
+            .locations
+            .iter()
+            .map(|loc| {
+                let (byte_lo, byte_hi) = loc.call_ident.byte_span;
+                let (line_lo, line_hi) = loc.call_expr.line_span;
+                let byte_range = (byte_lo - byte_min, byte_hi - byte_min);
+
+                let line_range = (line_lo - line_min, line_hi - line_min);
+                let (line_url, line_title) = link_to_loc(call_data, loc);
+
+                (byte_range, (line_range, line_url, line_title))
+            })
+            .unzip();
+
+        let (_, init_url, init_title) = &line_ranges[0];
+        let needs_expansion = line_max - line_min > NUM_VISIBLE_LINES;
+        let locations_encoded = serde_json::to_string(&line_ranges).unwrap();
+
+        write!(
+            w,
+            "<div class=\"scraped-example {expanded_cls}\" data-locs=\"{locations}\">\
+                <div class=\"scraped-example-title\">\
+                   {name} (<a href=\"{url}\">{title}</a>)\
+                </div>\
+                <div class=\"code-wrapper\">",
+            expanded_cls = if needs_expansion { "" } else { "expanded" },
+            name = call_data.display_name,
+            url = init_url,
+            title = init_title,
+            // The locations are encoded as a data attribute, so they can be read
+            // later by the JS for interactions.
+            locations = Escape(&locations_encoded)
+        );
+
+        if line_ranges.len() > 1 {
+            write!(w, r#"<span class="prev">&pr;</span> <span class="next">&sc;</span>"#);
+        }
+
+        if needs_expansion {
+            write!(w, r#"<span class="expand">&varr;</span>"#);
+        }
+
+        // Look for the example file in the source map if it exists, otherwise return a dummy span
+        let file_span = (|| {
+            let source_map = tcx.sess.source_map();
+            let crate_src = tcx.sess.local_crate_source_file.as_ref()?;
+            let abs_crate_src = crate_src.canonicalize().ok()?;
+            let crate_root = abs_crate_src.parent()?.parent()?;
+            let rel_path = path.strip_prefix(crate_root).ok()?;
+            let files = source_map.files();
+            let file = files.iter().find(|file| match &file.name {
+                FileName::Real(RealFileName::LocalPath(other_path)) => rel_path == other_path,
+                _ => false,
+            })?;
+            Some(rustc_span::Span::with_root_ctxt(
+                file.start_pos + BytePos(byte_min),
+                file.start_pos + BytePos(byte_max),
+            ))
+        })()
+        .unwrap_or(rustc_span::DUMMY_SP);
+
+        // The root path is the inverse of Context::current
+        let root_path = vec!["../"; cx.current.len() - 1].join("");
+
+        let mut decoration_info = FxHashMap::default();
+        decoration_info.insert("highlight focus", vec![byte_ranges.remove(0)]);
+        decoration_info.insert("highlight", byte_ranges);
+
+        sources::print_src(
+            w,
+            contents_subset,
+            call_data.edition,
+            file_span,
+            cx,
+            &root_path,
+            Some(highlight::DecorationInfo(decoration_info)),
+            sources::SourceContext::Embedded { offset: line_min },
+        );
+        write!(w, "</div></div>");
+
+        true
+    };
+
+    // The call locations are output in sequence, so that sequence needs to be determined.
+    // Ideally the most "relevant" examples would be shown first, but there's no general algorithm
+    // for determining relevance. Instead, we prefer the smallest examples being likely the easiest to
+    // understand at a glance.
+    let ordered_locations = {
+        let sort_criterion = |(_, call_data): &(_, &CallData)| {
+            // Use the first location because that's what the user will see initially
+            let (lo, hi) = call_data.locations[0].enclosing_item.byte_span;
+            hi - lo
+        };
+
+        let mut locs = call_locations.iter().collect::<Vec<_>>();
+        locs.sort_by_key(sort_criterion);
+        locs
+    };
+
+    let mut it = ordered_locations.into_iter().peekable();
+
+    // An example may fail to write if its source can't be read for some reason, so this method
+    // continues iterating until a write succeeds
+    let write_and_skip_failure = |w: &mut Buffer, it: &mut Peekable<_>| {
+        while let Some(example) = it.next() {
+            if write_example(&mut *w, example) {
+                break;
+            }
+        }
+    };
+
+    // Write just one example that's visible by default in the method's description.
+    write_and_skip_failure(w, &mut it);
+
+    // Then add the remaining examples in a hidden section.
+    if it.peek().is_some() {
+        write!(
+            w,
+            "<details class=\"rustdoc-toggle more-examples-toggle\">\
+                  <summary class=\"hideme\">\
+                     <span>More examples</span>\
+                  </summary>\
+                  <div class=\"hide-more\">Hide additional examples</div>\
+                  <div class=\"more-scraped-examples\">\
+                    <div class=\"toggle-line\"><div class=\"toggle-line-inner\"></div></div>\
+                    <div class=\"more-scraped-examples-inner\">"
+        );
+
+        // Only generate inline code for MAX_FULL_EXAMPLES number of examples. Otherwise we could
+        // make the page arbitrarily huge!
+        for _ in 0..MAX_FULL_EXAMPLES {
+            write_and_skip_failure(w, &mut it);
+        }
+
+        // For the remaining examples, generate a <ul> containing links to the source files.
+        if it.peek().is_some() {
+            write!(w, r#"<div class="example-links">Additional examples can be found in:<br><ul>"#);
+            it.for_each(|(_, call_data)| {
+                let (url, _) = link_to_loc(call_data, &call_data.locations[0]);
+                write!(
+                    w,
+                    r#"<li><a href="{url}">{name}</a></li>"#,
+                    url = url,
+                    name = call_data.display_name
+                );
+            });
+            write!(w, "</ul></div>");
+        }
+
+        write!(w, "</div></div></details>");
+    }
+
+    write!(w, "</div>");
+}
diff --git a/src/librustdoc/html/render/print_item.rs b/src/librustdoc/html/render/print_item.rs
new file mode 100644
index 000000000..99cf42919
--- /dev/null
+++ b/src/librustdoc/html/render/print_item.rs
@@ -0,0 +1,1974 @@
+use clean::AttributesExt;
+
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_hir as hir;
+use rustc_hir::def::CtorKind;
+use rustc_hir::def_id::DefId;
+use rustc_middle::middle::stability;
+use rustc_middle::span_bug;
+use rustc_middle::ty::layout::LayoutError;
+use rustc_middle::ty::{Adt, TyCtxt};
+use rustc_span::hygiene::MacroKind;
+use rustc_span::symbol::{kw, sym, Symbol};
+use rustc_target::abi::{Layout, Primitive, TagEncoding, Variants};
+use std::cmp::Ordering;
+use std::fmt;
+use std::rc::Rc;
+
+use super::{
+    collect_paths_for_type, document, ensure_trailing_slash, item_ty_to_section,
+    notable_traits_decl, render_assoc_item, render_assoc_items, render_attributes_in_code,
+    render_attributes_in_pre, render_impl, render_stability_since_raw, write_srclink,
+    AssocItemLink, Context, ImplRenderingParameters,
+};
+use crate::clean;
+use crate::config::ModuleSorting;
+use crate::formats::item_type::ItemType;
+use crate::formats::{AssocItemRender, Impl, RenderMode};
+use crate::html::escape::Escape;
+use crate::html::format::{
+    join_with_double_colon, print_abi_with_space, print_constness_with_space, print_where_clause,
+    Buffer, Ending, PrintWithSpace,
+};
+use crate::html::highlight;
+use crate::html::layout::Page;
+use crate::html::markdown::{HeadingOffset, MarkdownSummaryLine};
+use crate::html::url_parts_builder::UrlPartsBuilder;
+
+use askama::Template;
+use itertools::Itertools;
+
+const ITEM_TABLE_OPEN: &str = "<div class=\"item-table\">";
+const ITEM_TABLE_CLOSE: &str = "</div>";
+const ITEM_TABLE_ROW_OPEN: &str = "<div class=\"item-row\">";
+const ITEM_TABLE_ROW_CLOSE: &str = "</div>";
+
+// A component in a `use` path, like `string` in std::string::ToString
+struct PathComponent {
+    path: String,
+    name: Symbol,
+}
+
+#[derive(Template)]
+#[template(path = "print_item.html")]
+struct ItemVars<'a> {
+    page: &'a Page<'a>,
+    static_root_path: &'a str,
+    typ: &'a str,
+    name: &'a str,
+    item_type: &'a str,
+    path_components: Vec<PathComponent>,
+    stability_since_raw: &'a str,
+    src_href: Option<&'a str>,
+}
+
+/// Calls `print_where_clause` and returns `true` if a `where` clause was generated.
+fn print_where_clause_and_check<'a, 'tcx: 'a>(
+    buffer: &mut Buffer,
+    gens: &'a clean::Generics,
+    cx: &'a Context<'tcx>,
+) -> bool {
+    let len_before = buffer.len();
+    write!(buffer, "{}", print_where_clause(gens, cx, 0, Ending::Newline));
+    len_before != buffer.len()
+}
+
+pub(super) fn print_item(
+    cx: &mut Context<'_>,
+    item: &clean::Item,
+    buf: &mut Buffer,
+    page: &Page<'_>,
+) {
+    debug_assert!(!item.is_stripped());
+    let typ = match *item.kind {
+        clean::ModuleItem(_) => {
+            if item.is_crate() {
+                "Crate "
+            } else {
+                "Module "
+            }
+        }
+        clean::FunctionItem(..) | clean::ForeignFunctionItem(..) => "Function ",
+        clean::TraitItem(..) => "Trait ",
+        clean::StructItem(..) => "Struct ",
+        clean::UnionItem(..) => "Union ",
+        clean::EnumItem(..) => "Enum ",
+        clean::TypedefItem(..) => "Type Definition ",
+        clean::MacroItem(..) => "Macro ",
+        clean::ProcMacroItem(ref mac) => match mac.kind {
+            MacroKind::Bang => "Macro ",
+            MacroKind::Attr => "Attribute Macro ",
+            MacroKind::Derive => "Derive Macro ",
+        },
+        clean::PrimitiveItem(..) => "Primitive Type ",
+        clean::StaticItem(..) | clean::ForeignStaticItem(..) => "Static ",
+        clean::ConstantItem(..) => "Constant ",
+        clean::ForeignTypeItem => "Foreign Type ",
+        clean::KeywordItem => "Keyword ",
+        clean::OpaqueTyItem(..) => "Opaque Type ",
+        clean::TraitAliasItem(..) => "Trait Alias ",
+        _ => {
+            // We don't generate pages for any other type.
+            unreachable!();
+        }
+    };
+    let mut stability_since_raw = Buffer::new();
+    render_stability_since_raw(
+        &mut stability_since_raw,
+        item.stable_since(cx.tcx()),
+        item.const_stability(cx.tcx()),
+        None,
+        None,
+    );
+    let stability_since_raw: String = stability_since_raw.into_inner();
+
+    // Write source tag
+    //
+    // When this item is part of a `crate use` in a downstream crate, the
+    // source link in the downstream documentation will actually come back to
+    // this page, and this link will be auto-clicked. The `id` attribute is
+    // used to find the link to auto-click.
+    let src_href =
+        if cx.include_sources && !item.is_primitive() { cx.src_href(item) } else { None };
+
+    let path_components = if item.is_primitive() || item.is_keyword() {
+        vec![]
+    } else {
+        let cur = &cx.current;
+        let amt = if item.is_mod() { cur.len() - 1 } else { cur.len() };
+        cur.iter()
+            .enumerate()
+            .take(amt)
+            .map(|(i, component)| PathComponent {
+                path: "../".repeat(cur.len() - i - 1),
+                name: *component,
+            })
+            .collect()
+    };
+
+    let item_vars = ItemVars {
+        page,
+        static_root_path: page.get_static_root_path(),
+        typ,
+        name: item.name.as_ref().unwrap().as_str(),
+        item_type: &item.type_().to_string(),
+        path_components,
+        stability_since_raw: &stability_since_raw,
+        src_href: src_href.as_deref(),
+    };
+
+    item_vars.render_into(buf).unwrap();
+
+    match &*item.kind {
+        clean::ModuleItem(ref m) => item_module(buf, cx, item, &m.items),
+        clean::FunctionItem(ref f) | clean::ForeignFunctionItem(ref f) => {
+            item_function(buf, cx, item, f)
+        }
+        clean::TraitItem(ref t) => item_trait(buf, cx, item, t),
+        clean::StructItem(ref s) => item_struct(buf, cx, item, s),
+        clean::UnionItem(ref s) => item_union(buf, cx, item, s),
+        clean::EnumItem(ref e) => item_enum(buf, cx, item, e),
+        clean::TypedefItem(ref t) => item_typedef(buf, cx, item, t),
+        clean::MacroItem(ref m) => item_macro(buf, cx, item, m),
+        clean::ProcMacroItem(ref m) => item_proc_macro(buf, cx, item, m),
+        clean::PrimitiveItem(_) => item_primitive(buf, cx, item),
+        clean::StaticItem(ref i) | clean::ForeignStaticItem(ref i) => item_static(buf, cx, item, i),
+        clean::ConstantItem(ref c) => item_constant(buf, cx, item, c),
+        clean::ForeignTypeItem => item_foreign_type(buf, cx, item),
+        clean::KeywordItem => item_keyword(buf, cx, item),
+        clean::OpaqueTyItem(ref e) => item_opaque_ty(buf, cx, item, e),
+        clean::TraitAliasItem(ref ta) => item_trait_alias(buf, cx, item, ta),
+        _ => {
+            // We don't generate pages for any other type.
+            unreachable!();
+        }
+    }
+}
+
+/// For large structs, enums, unions, etc, determine whether to hide their fields
+fn should_hide_fields(n_fields: usize) -> bool {
+    n_fields > 12
+}
+
+fn toggle_open(w: &mut Buffer, text: impl fmt::Display) {
+    write!(
+        w,
+        "<details class=\"rustdoc-toggle type-contents-toggle\">\
+            <summary class=\"hideme\">\
+                <span>Show {}</span>\
+            </summary>",
+        text
+    );
+}
+
+fn toggle_close(w: &mut Buffer) {
+    w.write_str("</details>");
+}
+
+fn item_module(w: &mut Buffer, cx: &mut Context<'_>, item: &clean::Item, items: &[clean::Item]) {
+    document(w, cx, item, None, HeadingOffset::H2);
+
+    let mut indices = (0..items.len()).filter(|i| !items[*i].is_stripped()).collect::<Vec<usize>>();
+
+    // the order of item types in the listing
+    fn reorder(ty: ItemType) -> u8 {
+        match ty {
+            ItemType::ExternCrate => 0,
+            ItemType::Import => 1,
+            ItemType::Primitive => 2,
+            ItemType::Module => 3,
+            ItemType::Macro => 4,
+            ItemType::Struct => 5,
+            ItemType::Enum => 6,
+            ItemType::Constant => 7,
+            ItemType::Static => 8,
+            ItemType::Trait => 9,
+            ItemType::Function => 10,
+            ItemType::Typedef => 12,
+            ItemType::Union => 13,
+            _ => 14 + ty as u8,
+        }
+    }
+
+    fn cmp(
+        i1: &clean::Item,
+        i2: &clean::Item,
+        idx1: usize,
+        idx2: usize,
+        tcx: TyCtxt<'_>,
+    ) -> Ordering {
+        let ty1 = i1.type_();
+        let ty2 = i2.type_();
+        if item_ty_to_section(ty1) != item_ty_to_section(ty2)
+            || (ty1 != ty2 && (ty1 == ItemType::ExternCrate || ty2 == ItemType::ExternCrate))
+        {
+            return (reorder(ty1), idx1).cmp(&(reorder(ty2), idx2));
+        }
+        let s1 = i1.stability(tcx).as_ref().map(|s| s.level);
+        let s2 = i2.stability(tcx).as_ref().map(|s| s.level);
+        if let (Some(a), Some(b)) = (s1, s2) {
+            match (a.is_stable(), b.is_stable()) {
+                (true, true) | (false, false) => {}
+                (false, true) => return Ordering::Less,
+                (true, false) => return Ordering::Greater,
+            }
+        }
+        let lhs = i1.name.unwrap_or(kw::Empty);
+        let rhs = i2.name.unwrap_or(kw::Empty);
+        compare_names(lhs.as_str(), rhs.as_str())
+    }
+
+    match cx.shared.module_sorting {
+        ModuleSorting::Alphabetical => {
+            indices.sort_by(|&i1, &i2| cmp(&items[i1], &items[i2], i1, i2, cx.tcx()));
+        }
+        ModuleSorting::DeclarationOrder => {}
+    }
+    // This call is to remove re-export duplicates in cases such as:
+    //
+    // ```
+    // pub(crate) mod foo {
+    //     pub(crate) mod bar {
+    //         pub(crate) trait Double { fn foo(); }
+    //     }
+    // }
+    //
+    // pub(crate) use foo::bar::*;
+    // pub(crate) use foo::*;
+    // ```
+    //
+    // `Double` will appear twice in the generated docs.
+    //
+    // FIXME: This code is quite ugly and could be improved. Small issue: DefId
+    // can be identical even if the elements are different (mostly in imports).
+    // So in case this is an import, we keep everything by adding a "unique id"
+    // (which is the position in the vector).
+    indices.dedup_by_key(|i| {
+        (
+            items[*i].item_id,
+            if items[*i].name.is_some() { Some(full_path(cx, &items[*i])) } else { None },
+            items[*i].type_(),
+            if items[*i].is_import() { *i } else { 0 },
+        )
+    });
+
+    debug!("{:?}", indices);
+    let mut last_section = None;
+
+    for &idx in &indices {
+        let myitem = &items[idx];
+        if myitem.is_stripped() {
+            continue;
+        }
+
+        let my_section = item_ty_to_section(myitem.type_());
+        if Some(my_section) != last_section {
+            if last_section.is_some() {
+                w.write_str(ITEM_TABLE_CLOSE);
+            }
+            last_section = Some(my_section);
+            write!(
+                w,
+                "<h2 id=\"{id}\" class=\"small-section-header\">\
+                    <a href=\"#{id}\">{name}</a>\
+                 </h2>{}",
+                ITEM_TABLE_OPEN,
+                id = cx.derive_id(my_section.id().to_owned()),
+                name = my_section.name(),
+            );
+        }
+
+        match *myitem.kind {
+            clean::ExternCrateItem { ref src } => {
+                use crate::html::format::anchor;
+
+                w.write_str(ITEM_TABLE_ROW_OPEN);
+                match *src {
+                    Some(src) => write!(
+                        w,
+                        "<div class=\"item-left\"><code>{}extern crate {} as {};",
+                        myitem.visibility.print_with_space(myitem.item_id, cx),
+                        anchor(myitem.item_id.expect_def_id(), src, cx),
+                        myitem.name.unwrap(),
+                    ),
+                    None => write!(
+                        w,
+                        "<div class=\"item-left\"><code>{}extern crate {};",
+                        myitem.visibility.print_with_space(myitem.item_id, cx),
+                        anchor(myitem.item_id.expect_def_id(), myitem.name.unwrap(), cx),
+                    ),
+                }
+                w.write_str("</code></div>");
+                w.write_str(ITEM_TABLE_ROW_CLOSE);
+            }
+
+            clean::ImportItem(ref import) => {
+                let (stab, stab_tags) = if let Some(import_def_id) = import.source.did {
+                    let ast_attrs = cx.tcx().get_attrs_unchecked(import_def_id);
+                    let import_attrs = Box::new(clean::Attributes::from_ast(ast_attrs));
+
+                    // Just need an item with the correct def_id and attrs
+                    let import_item = clean::Item {
+                        item_id: import_def_id.into(),
+                        attrs: import_attrs,
+                        cfg: ast_attrs.cfg(cx.tcx(), &cx.cache().hidden_cfg),
+                        ..myitem.clone()
+                    };
+
+                    let stab = import_item.stability_class(cx.tcx());
+                    let stab_tags = Some(extra_info_tags(&import_item, item, cx.tcx()));
+                    (stab, stab_tags)
+                } else {
+                    (None, None)
+                };
+
+                let add = if stab.is_some() { " " } else { "" };
+
+                w.write_str(ITEM_TABLE_ROW_OPEN);
+                let id = match import.kind {
+                    clean::ImportKind::Simple(s) => {
+                        format!(" id=\"{}\"", cx.derive_id(format!("reexport.{}", s)))
+                    }
+                    clean::ImportKind::Glob => String::new(),
+                };
+                write!(
+                    w,
+                    "<div class=\"item-left {stab}{add}import-item\"{id}>\
+                         <code>{vis}{imp}</code>\
+                     </div>\
+                     <div class=\"item-right docblock-short\">{stab_tags}</div>",
+                    stab = stab.unwrap_or_default(),
+                    vis = myitem.visibility.print_with_space(myitem.item_id, cx),
+                    imp = import.print(cx),
+                    stab_tags = stab_tags.unwrap_or_default(),
+                );
+                w.write_str(ITEM_TABLE_ROW_CLOSE);
+            }
+
+            _ => {
+                if myitem.name.is_none() {
+                    continue;
+                }
+
+                let unsafety_flag = match *myitem.kind {
+                    clean::FunctionItem(_) | clean::ForeignFunctionItem(_)
+                        if myitem.fn_header(cx.tcx()).unwrap().unsafety
+                            == hir::Unsafety::Unsafe =>
+                    {
+                        "<a title=\"unsafe function\" href=\"#\"><sup>⚠</sup></a>"
+                    }
+                    _ => "",
+                };
+
+                let stab = myitem.stability_class(cx.tcx());
+                let add = if stab.is_some() { " " } else { "" };
+
+                let visibility_emoji = match myitem.visibility {
+                    clean::Visibility::Restricted(_) => {
+                        "<span title=\"Restricted Visibility\">&nbsp;🔒</span> "
+                    }
+                    _ => "",
+                };
+
+                let doc_value = myitem.doc_value().unwrap_or_default();
+                w.write_str(ITEM_TABLE_ROW_OPEN);
+                write!(
+                    w,
+                    "<div class=\"item-left {stab}{add}module-item\">\
+                        <a class=\"{class}\" href=\"{href}\" title=\"{title}\">{name}</a>\
+                        {visibility_emoji}\
+                        {unsafety_flag}\
+                        {stab_tags}\
+                     </div>\
+                     <div class=\"item-right docblock-short\">{docs}</div>",
+                    name = myitem.name.unwrap(),
+                    visibility_emoji = visibility_emoji,
+                    stab_tags = extra_info_tags(myitem, item, cx.tcx()),
+                    docs = MarkdownSummaryLine(&doc_value, &myitem.links(cx)).into_string(),
+                    class = myitem.type_(),
+                    add = add,
+                    stab = stab.unwrap_or_default(),
+                    unsafety_flag = unsafety_flag,
+                    href = item_path(myitem.type_(), myitem.name.unwrap().as_str()),
+                    title = [full_path(cx, myitem), myitem.type_().to_string()]
+                        .iter()
+                        .filter_map(|s| if !s.is_empty() { Some(s.as_str()) } else { None })
+                        .collect::<Vec<_>>()
+                        .join(" "),
+                );
+                w.write_str(ITEM_TABLE_ROW_CLOSE);
+            }
+        }
+    }
+
+    if last_section.is_some() {
+        w.write_str(ITEM_TABLE_CLOSE);
+    }
+}
+
+/// Render the stability, deprecation and portability tags that are displayed in the item's summary
+/// at the module level.
+fn extra_info_tags(item: &clean::Item, parent: &clean::Item, tcx: TyCtxt<'_>) -> String {
+    let mut tags = String::new();
+
+    fn tag_html(class: &str, title: &str, contents: &str) -> String {
+        format!(r#"<span class="stab {}" title="{}">{}</span>"#, class, Escape(title), contents)
+    }
+
+    // The trailing space after each tag is to space it properly against the rest of the docs.
+    if let Some(depr) = &item.deprecation(tcx) {
+        let mut message = "Deprecated";
+        if !stability::deprecation_in_effect(depr) {
+            message = "Deprecation planned";
+        }
+        tags += &tag_html("deprecated", "", message);
+    }
+
+    // The "rustc_private" crates are permanently unstable so it makes no sense
+    // to render "unstable" everywhere.
+    if item.stability(tcx).as_ref().map(|s| s.is_unstable() && s.feature != sym::rustc_private)
+        == Some(true)
+    {
+        tags += &tag_html("unstable", "", "Experimental");
+    }
+
+    let cfg = match (&item.cfg, parent.cfg.as_ref()) {
+        (Some(cfg), Some(parent_cfg)) => cfg.simplify_with(parent_cfg),
+        (cfg, _) => cfg.as_deref().cloned(),
+    };
+
+    debug!("Portability {:?} - {:?} = {:?}", item.cfg, parent.cfg, cfg);
+    if let Some(ref cfg) = cfg {
+        tags += &tag_html("portability", &cfg.render_long_plain(), &cfg.render_short_html());
+    }
+
+    tags
+}
+
+fn item_function(w: &mut Buffer, cx: &mut Context<'_>, it: &clean::Item, f: &clean::Function) {
+    let header = it.fn_header(cx.tcx()).expect("printing a function which isn't a function");
+    let constness = print_constness_with_space(&header.constness, it.const_stability(cx.tcx()));
+    let unsafety = header.unsafety.print_with_space();
+    let abi = print_abi_with_space(header.abi).to_string();
+    let asyncness = header.asyncness.print_with_space();
+    let visibility = it.visibility.print_with_space(it.item_id, cx).to_string();
+    let name = it.name.unwrap();
+
+    let generics_len = format!("{:#}", f.generics.print(cx)).len();
+    let header_len = "fn ".len()
+        + visibility.len()
+        + constness.len()
+        + asyncness.len()
+        + unsafety.len()
+        + abi.len()
+        + name.as_str().len()
+        + generics_len;
+
+    wrap_into_docblock(w, |w| {
+        wrap_item(w, "fn", |w| {
+            render_attributes_in_pre(w, it, "");
+            w.reserve(header_len);
+            write!(
+                w,
+                "{vis}{constness}{asyncness}{unsafety}{abi}fn \
+                 {name}{generics}{decl}{notable_traits}{where_clause}",
+                vis = visibility,
+                constness = constness,
+                asyncness = asyncness,
+                unsafety = unsafety,
+                abi = abi,
+                name = name,
+                generics = f.generics.print(cx),
+                where_clause = print_where_clause(&f.generics, cx, 0, Ending::Newline),
+                decl = f.decl.full_print(header_len, 0, header.asyncness, cx),
+                notable_traits = notable_traits_decl(&f.decl, cx),
+            );
+        });
+    });
+    document(w, cx, it, None, HeadingOffset::H2)
+}
+
+fn item_trait(w: &mut Buffer, cx: &mut Context<'_>, it: &clean::Item, t: &clean::Trait) {
+    let bounds = bounds(&t.bounds, false, cx);
+    let required_types = t.items.iter().filter(|m| m.is_ty_associated_type()).collect::<Vec<_>>();
+    let provided_types = t.items.iter().filter(|m| m.is_associated_type()).collect::<Vec<_>>();
+    let required_consts = t.items.iter().filter(|m| m.is_ty_associated_const()).collect::<Vec<_>>();
+    let provided_consts = t.items.iter().filter(|m| m.is_associated_const()).collect::<Vec<_>>();
+    let required_methods = t.items.iter().filter(|m| m.is_ty_method()).collect::<Vec<_>>();
+    let provided_methods = t.items.iter().filter(|m| m.is_method()).collect::<Vec<_>>();
+    let count_types = required_types.len() + provided_types.len();
+    let count_consts = required_consts.len() + provided_consts.len();
+    let count_methods = required_methods.len() + provided_methods.len();
+    let must_implement_one_of_functions =
+        cx.tcx().trait_def(t.def_id).must_implement_one_of.clone();
+
+    // Output the trait definition
+    wrap_into_docblock(w, |w| {
+        wrap_item(w, "trait", |w| {
+            render_attributes_in_pre(w, it, "");
+            write!(
+                w,
+                "{}{}{}trait {}{}{}",
+                it.visibility.print_with_space(it.item_id, cx),
+                t.unsafety(cx.tcx()).print_with_space(),
+                if t.is_auto(cx.tcx()) { "auto " } else { "" },
+                it.name.unwrap(),
+                t.generics.print(cx),
+                bounds
+            );
+
+            if !t.generics.where_predicates.is_empty() {
+                write!(w, "{}", print_where_clause(&t.generics, cx, 0, Ending::Newline));
+            } else {
+                w.write_str(" ");
+            }
+
+            if t.items.is_empty() {
+                w.write_str("{ }");
+            } else {
+                // FIXME: we should be using a derived_id for the Anchors here
+                w.write_str("{\n");
+                let mut toggle = false;
+
+                // If there are too many associated types, hide _everything_
+                if should_hide_fields(count_types) {
+                    toggle = true;
+                    toggle_open(
+                        w,
+                        format_args!(
+                            "{} associated items",
+                            count_types + count_consts + count_methods
+                        ),
+                    );
+                }
+                for types in [&required_types, &provided_types] {
+                    for t in types {
+                        render_assoc_item(
+                            w,
+                            t,
+                            AssocItemLink::Anchor(None),
+                            ItemType::Trait,
+                            cx,
+                            RenderMode::Normal,
+                        );
+                        w.write_str(";\n");
+                    }
+                }
+                // If there are too many associated constants, hide everything after them
+                // We also do this if the types + consts is large because otherwise we could
+                // render a bunch of types and _then_ a bunch of consts just because both were
+                // _just_ under the limit
+                if !toggle && should_hide_fields(count_types + count_consts) {
+                    toggle = true;
+                    toggle_open(
+                        w,
+                        format_args!(
+                            "{} associated constant{} and {} method{}",
+                            count_consts,
+                            pluralize(count_consts),
+                            count_methods,
+                            pluralize(count_methods),
+                        ),
+                    );
+                }
+                if count_types != 0 && (count_consts != 0 || count_methods != 0) {
+                    w.write_str("\n");
+                }
+                for consts in [&required_consts, &provided_consts] {
+                    for c in consts {
+                        render_assoc_item(
+                            w,
+                            c,
+                            AssocItemLink::Anchor(None),
+                            ItemType::Trait,
+                            cx,
+                            RenderMode::Normal,
+                        );
+                        w.write_str(";\n");
+                    }
+                }
+                if !toggle && should_hide_fields(count_methods) {
+                    toggle = true;
+                    toggle_open(w, format_args!("{} methods", count_methods));
+                }
+                if count_consts != 0 && count_methods != 0 {
+                    w.write_str("\n");
+                }
+                for (pos, m) in required_methods.iter().enumerate() {
+                    render_assoc_item(
+                        w,
+                        m,
+                        AssocItemLink::Anchor(None),
+                        ItemType::Trait,
+                        cx,
+                        RenderMode::Normal,
+                    );
+                    w.write_str(";\n");
+
+                    if pos < required_methods.len() - 1 {
+                        w.write_str("<span class=\"item-spacer\"></span>");
+                    }
+                }
+                if !required_methods.is_empty() && !provided_methods.is_empty() {
+                    w.write_str("\n");
+                }
+                for (pos, m) in provided_methods.iter().enumerate() {
+                    render_assoc_item(
+                        w,
+                        m,
+                        AssocItemLink::Anchor(None),
+                        ItemType::Trait,
+                        cx,
+                        RenderMode::Normal,
+                    );
+                    match *m.kind {
+                        clean::MethodItem(ref inner, _)
+                            if !inner.generics.where_predicates.is_empty() =>
+                        {
+                            w.write_str(",\n    { ... }\n");
+                        }
+                        _ => {
+                            w.write_str(" { ... }\n");
+                        }
+                    }
+
+                    if pos < provided_methods.len() - 1 {
+                        w.write_str("<span class=\"item-spacer\"></span>");
+                    }
+                }
+                if toggle {
+                    toggle_close(w);
+                }
+                w.write_str("}");
+            }
+        });
+    });
+
+    // Trait documentation
+    document(w, cx, it, None, HeadingOffset::H2);
+
+    fn write_small_section_header(w: &mut Buffer, id: &str, title: &str, extra_content: &str) {
+        write!(
+            w,
+            "<h2 id=\"{0}\" class=\"small-section-header\">\
+                {1}<a href=\"#{0}\" class=\"anchor\"></a>\
+             </h2>{2}",
+            id, title, extra_content
+        )
+    }
+
+    fn trait_item(w: &mut Buffer, cx: &mut Context<'_>, m: &clean::Item, t: &clean::Item) {
+        let name = m.name.unwrap();
+        info!("Documenting {} on {:?}", name, t.name);
+        let item_type = m.type_();
+        let id = cx.derive_id(format!("{}.{}", item_type, name));
+        let mut content = Buffer::empty_from(w);
+        document(&mut content, cx, m, Some(t), HeadingOffset::H5);
+        let toggled = !content.is_empty();
+        if toggled {
+            write!(w, "<details class=\"rustdoc-toggle\" open><summary>");
+        }
+        write!(w, "<div id=\"{}\" class=\"method has-srclink\">", id);
+        write!(w, "<div class=\"rightside\">");
+
+        let has_stability = render_stability_since(w, m, t, cx.tcx());
+        if has_stability {
+            w.write_str(" · ");
+        }
+        write_srclink(cx, m, w);
+        write!(w, "</div>");
+        write!(w, "<h4 class=\"code-header\">");
+        render_assoc_item(
+            w,
+            m,
+            AssocItemLink::Anchor(Some(&id)),
+            ItemType::Impl,
+            cx,
+            RenderMode::Normal,
+        );
+        w.write_str("</h4>");
+        w.write_str("</div>");
+        if toggled {
+            write!(w, "</summary>");
+            w.push_buffer(content);
+            write!(w, "</details>");
+        }
+    }
+
+    if !required_types.is_empty() {
+        write_small_section_header(
+            w,
+            "required-associated-types",
+            "Required Associated Types",
+            "<div class=\"methods\">",
+        );
+        for t in required_types {
+            trait_item(w, cx, t, it);
+        }
+        w.write_str("</div>");
+    }
+    if !provided_types.is_empty() {
+        write_small_section_header(
+            w,
+            "provided-associated-types",
+            "Provided Associated Types",
+            "<div class=\"methods\">",
+        );
+        for t in provided_types {
+            trait_item(w, cx, t, it);
+        }
+        w.write_str("</div>");
+    }
+
+    if !required_consts.is_empty() {
+        write_small_section_header(
+            w,
+            "required-associated-consts",
+            "Required Associated Constants",
+            "<div class=\"methods\">",
+        );
+        for t in required_consts {
+            trait_item(w, cx, t, it);
+        }
+        w.write_str("</div>");
+    }
+    if !provided_consts.is_empty() {
+        write_small_section_header(
+            w,
+            "provided-associated-consts",
+            "Provided Associated Constants",
+            "<div class=\"methods\">",
+        );
+        for t in provided_consts {
+            trait_item(w, cx, t, it);
+        }
+        w.write_str("</div>");
+    }
+
+    // Output the documentation for each function individually
+    if !required_methods.is_empty() || must_implement_one_of_functions.is_some() {
+        write_small_section_header(
+            w,
+            "required-methods",
+            "Required Methods",
+            "<div class=\"methods\">",
+        );
+
+        if let Some(list) = must_implement_one_of_functions.as_deref() {
+            write!(
+                w,
+                "<div class=\"stab must_implement\">At least one of the `{}` methods is required.</div>",
+                list.iter().join("`, `")
+            );
+        }
+
+        for m in required_methods {
+            trait_item(w, cx, m, it);
+        }
+        w.write_str("</div>");
+    }
+    if !provided_methods.is_empty() {
+        write_small_section_header(
+            w,
+            "provided-methods",
+            "Provided Methods",
+            "<div class=\"methods\">",
+        );
+        for m in provided_methods {
+            trait_item(w, cx, m, it);
+        }
+        w.write_str("</div>");
+    }
+
+    // If there are methods directly on this trait object, render them here.
+    render_assoc_items(w, cx, it, it.item_id.expect_def_id(), AssocItemRender::All);
+
+    let cloned_shared = Rc::clone(&cx.shared);
+    let cache = &cloned_shared.cache;
+    let mut extern_crates = FxHashSet::default();
+    if let Some(implementors) = cache.implementors.get(&it.item_id.expect_def_id()) {
+        // The DefId is for the first Type found with that name. The bool is
+        // if any Types with the same name but different DefId have been found.
+        let mut implementor_dups: FxHashMap<Symbol, (DefId, bool)> = FxHashMap::default();
+        for implementor in implementors {
+            if let Some(did) = implementor.inner_impl().for_.without_borrowed_ref().def_id(cache) &&
+                !did.is_local() {
+                extern_crates.insert(did.krate);
+            }
+            match implementor.inner_impl().for_.without_borrowed_ref() {
+                clean::Type::Path { ref path } if !path.is_assoc_ty() => {
+                    let did = path.def_id();
+                    let &mut (prev_did, ref mut has_duplicates) =
+                        implementor_dups.entry(path.last()).or_insert((did, false));
+                    if prev_did != did {
+                        *has_duplicates = true;
+                    }
+                }
+                _ => {}
+            }
+        }
+
+        let (local, foreign) =
+            implementors.iter().partition::<Vec<_>, _>(|i| i.is_on_local_type(cx));
+
+        let (mut synthetic, mut concrete): (Vec<&&Impl>, Vec<&&Impl>) =
+            local.iter().partition(|i| i.inner_impl().kind.is_auto());
+
+        synthetic.sort_by(|a, b| compare_impl(a, b, cx));
+        concrete.sort_by(|a, b| compare_impl(a, b, cx));
+
+        if !foreign.is_empty() {
+            write_small_section_header(w, "foreign-impls", "Implementations on Foreign Types", "");
+
+            for implementor in foreign {
+                let provided_methods = implementor.inner_impl().provided_trait_methods(cx.tcx());
+                let assoc_link =
+                    AssocItemLink::GotoSource(implementor.impl_item.item_id, &provided_methods);
+                render_impl(
+                    w,
+                    cx,
+                    implementor,
+                    it,
+                    assoc_link,
+                    RenderMode::Normal,
+                    None,
+                    &[],
+                    ImplRenderingParameters {
+                        show_def_docs: false,
+                        show_default_items: false,
+                        show_non_assoc_items: true,
+                        toggle_open_by_default: false,
+                    },
+                );
+            }
+        }
+
+        write_small_section_header(
+            w,
+            "implementors",
+            "Implementors",
+            "<div class=\"item-list\" id=\"implementors-list\">",
+        );
+        for implementor in concrete {
+            render_implementor(cx, implementor, it, w, &implementor_dups, &[]);
+        }
+        w.write_str("</div>");
+
+        if t.is_auto(cx.tcx()) {
+            write_small_section_header(
+                w,
+                "synthetic-implementors",
+                "Auto implementors",
+                "<div class=\"item-list\" id=\"synthetic-implementors-list\">",
+            );
+            for implementor in synthetic {
+                render_implementor(
+                    cx,
+                    implementor,
+                    it,
+                    w,
+                    &implementor_dups,
+                    &collect_paths_for_type(implementor.inner_impl().for_.clone(), cache),
+                );
+            }
+            w.write_str("</div>");
+        }
+    } else {
+        // even without any implementations to write in, we still want the heading and list, so the
+        // implementors javascript file pulled in below has somewhere to write the impls into
+        write_small_section_header(
+            w,
+            "implementors",
+            "Implementors",
+            "<div class=\"item-list\" id=\"implementors-list\"></div>",
+        );
+
+        if t.is_auto(cx.tcx()) {
+            write_small_section_header(
+                w,
+                "synthetic-implementors",
+                "Auto implementors",
+                "<div class=\"item-list\" id=\"synthetic-implementors-list\"></div>",
+            );
+        }
+    }
+
+    // Include implementors in crates that depend on the current crate.
+    //
+    // This is complicated by the way rustdoc is invoked, which is basically
+    // the same way rustc is invoked: it gets called, one at a time, for each
+    // crate. When building the rustdocs for the current crate, rustdoc can
+    // see crate metadata for its dependencies, but cannot see metadata for its
+    // dependents.
+    //
+    // To make this work, we generate a "hook" at this stage, and our
+    // dependents can "plug in" to it when they build. For simplicity's sake,
+    // it's [JSONP]: a JavaScript file with the data we need (and can parse),
+    // surrounded by a tiny wrapper that the Rust side ignores, but allows the
+    // JavaScript side to include without having to worry about Same Origin
+    // Policy. The code for *that* is in `write_shared.rs`.
+    //
+    // This is further complicated by `#[doc(inline)]`. We want all copies
+    // of an inlined trait to reference the same JS file, to address complex
+    // dependency graphs like this one (lower crates depend on higher crates):
+    //
+    // ```text
+    //  --------------------------------------------
+    //  |            crate A: trait Foo            |
+    //  --------------------------------------------
+    //      |                               |
+    //  --------------------------------    |
+    //  | crate B: impl A::Foo for Bar |    |
+    //  --------------------------------    |
+    //      |                               |
+    //  ---------------------------------------------
+    //  | crate C: #[doc(inline)] use A::Foo as Baz |
+    //  |          impl Baz for Quux                |
+    //  ---------------------------------------------
+    // ```
+    //
+    // Basically, we want `C::Baz` and `A::Foo` to show the same set of
+    // impls, which is easier if they both treat `/implementors/A/trait.Foo.js`
+    // as the Single Source of Truth.
+    //
+    // We also want the `impl Baz for Quux` to be written to
+    // `trait.Foo.js`. However, when we generate plain HTML for `C::Baz`,
+    // we're going to want to generate plain HTML for `impl Baz for Quux` too,
+    // because that'll load faster, and it's better for SEO. And we don't want
+    // the same impl to show up twice on the same page.
+    //
+    // To make this work, the implementors JS file has a structure kinda
+    // like this:
+    //
+    // ```js
+    // JSONP({
+    // "B": {"impl A::Foo for Bar"},
+    // "C": {"impl Baz for Quux"},
+    // });
+    // ```
+    //
+    // First of all, this means we can rebuild a crate, and it'll replace its own
+    // data if something changes. That is, `rustdoc` is idempotent. The other
+    // advantage is that we can list the crates that get included in the HTML,
+    // and ignore them when doing the JavaScript-based part of rendering.
+    // So C's HTML will have something like this:
+    //
+    // ```html
+    // <script type="text/javascript" src="/implementors/A/trait.Foo.js"
+    //     data-ignore-extern-crates="A,B" async></script>
+    // ```
+    //
+    // And, when the JS runs, anything in data-ignore-extern-crates is known
+    // to already be in the HTML, and will be ignored.
+    //
+    // [JSONP]: https://en.wikipedia.org/wiki/JSONP
+    let mut js_src_path: UrlPartsBuilder = std::iter::repeat("..")
+        .take(cx.current.len())
+        .chain(std::iter::once("implementors"))
+        .collect();
+    if let Some(did) = it.item_id.as_def_id() &&
+        let get_extern = { || cache.external_paths.get(&did).map(|s| s.0.clone()) } &&
+        let Some(fqp) = cache.exact_paths.get(&did).cloned().or_else(get_extern) {
+        js_src_path.extend(fqp[..fqp.len() - 1].iter().copied());
+        js_src_path.push_fmt(format_args!("{}.{}.js", it.type_(), fqp.last().unwrap()));
+    } else {
+        js_src_path.extend(cx.current.iter().copied());
+        js_src_path.push_fmt(format_args!("{}.{}.js", it.type_(), it.name.unwrap()));
+    }
+    let extern_crates = extern_crates
+        .into_iter()
+        .map(|cnum| cx.shared.tcx.crate_name(cnum).to_string())
+        .collect::<Vec<_>>()
+        .join(",");
+    write!(
+        w,
+        "<script type=\"text/javascript\" src=\"{src}\" data-ignore-extern-crates=\"{extern_crates}\" async></script>",
+        src = js_src_path.finish(),
+    );
+}
+
+fn item_trait_alias(w: &mut Buffer, cx: &mut Context<'_>, it: &clean::Item, t: &clean::TraitAlias) {
+    wrap_into_docblock(w, |w| {
+        wrap_item(w, "trait-alias", |w| {
+            render_attributes_in_pre(w, it, "");
+            write!(
+                w,
+                "trait {}{}{} = {};",
+                it.name.unwrap(),
+                t.generics.print(cx),
+                print_where_clause(&t.generics, cx, 0, Ending::Newline),
+                bounds(&t.bounds, true, cx)
+            );
+        });
+    });
+
+    document(w, cx, it, None, HeadingOffset::H2);
+
+    // Render any items associated directly to this alias, as otherwise they
+    // won't be visible anywhere in the docs. It would be nice to also show
+    // associated items from the aliased type (see discussion in #32077), but
+    // we need #14072 to make sense of the generics.
+    render_assoc_items(w, cx, it, it.item_id.expect_def_id(), AssocItemRender::All)
+}
+
+fn item_opaque_ty(w: &mut Buffer, cx: &mut Context<'_>, it: &clean::Item, t: &clean::OpaqueTy) {
+    wrap_into_docblock(w, |w| {
+        wrap_item(w, "opaque", |w| {
+            render_attributes_in_pre(w, it, "");
+            write!(
+                w,
+                "type {}{}{where_clause} = impl {bounds};",
+                it.name.unwrap(),
+                t.generics.print(cx),
+                where_clause = print_where_clause(&t.generics, cx, 0, Ending::Newline),
+                bounds = bounds(&t.bounds, false, cx),
+            );
+        });
+    });
+
+    document(w, cx, it, None, HeadingOffset::H2);
+
+    // Render any items associated directly to this alias, as otherwise they
+    // won't be visible anywhere in the docs. It would be nice to also show
+    // associated items from the aliased type (see discussion in #32077), but
+    // we need #14072 to make sense of the generics.
+    render_assoc_items(w, cx, it, it.item_id.expect_def_id(), AssocItemRender::All)
+}
+
+fn item_typedef(w: &mut Buffer, cx: &mut Context<'_>, it: &clean::Item, t: &clean::Typedef) {
+    fn write_content(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, t: &clean::Typedef) {
+        wrap_item(w, "typedef", |w| {
+            render_attributes_in_pre(w, it, "");
+            write!(w, "{}", it.visibility.print_with_space(it.item_id, cx));
+            write!(
+                w,
+                "type {}{}{where_clause} = {type_};",
+                it.name.unwrap(),
+                t.generics.print(cx),
+                where_clause = print_where_clause(&t.generics, cx, 0, Ending::Newline),
+                type_ = t.type_.print(cx),
+            );
+        });
+    }
+
+    wrap_into_docblock(w, |w| write_content(w, cx, it, t));
+
+    document(w, cx, it, None, HeadingOffset::H2);
+
+    let def_id = it.item_id.expect_def_id();
+    // Render any items associated directly to this alias, as otherwise they
+    // won't be visible anywhere in the docs. It would be nice to also show
+    // associated items from the aliased type (see discussion in #32077), but
+    // we need #14072 to make sense of the generics.
+    render_assoc_items(w, cx, it, def_id, AssocItemRender::All);
+    document_type_layout(w, cx, def_id);
+}
+
+fn item_union(w: &mut Buffer, cx: &mut Context<'_>, it: &clean::Item, s: &clean::Union) {
+    wrap_into_docblock(w, |w| {
+        wrap_item(w, "union", |w| {
+            render_attributes_in_pre(w, it, "");
+            render_union(w, it, Some(&s.generics), &s.fields, "", cx);
+        });
+    });
+
+    document(w, cx, it, None, HeadingOffset::H2);
+
+    let mut fields = s
+        .fields
+        .iter()
+        .filter_map(|f| match *f.kind {
+            clean::StructFieldItem(ref ty) => Some((f, ty)),
+            _ => None,
+        })
+        .peekable();
+    if fields.peek().is_some() {
+        write!(
+            w,
+            "<h2 id=\"fields\" class=\"fields small-section-header\">\
+                Fields<a href=\"#fields\" class=\"anchor\"></a>\
+            </h2>"
+        );
+        for (field, ty) in fields {
+            let name = field.name.expect("union field name");
+            let id = format!("{}.{}", ItemType::StructField, name);
+            write!(
+                w,
+                "<span id=\"{id}\" class=\"{shortty} small-section-header\">\
+                     <a href=\"#{id}\" class=\"anchor field\"></a>\
+                     <code>{name}: {ty}</code>\
+                 </span>",
+                id = id,
+                name = name,
+                shortty = ItemType::StructField,
+                ty = ty.print(cx),
+            );
+            if let Some(stability_class) = field.stability_class(cx.tcx()) {
+                write!(w, "<span class=\"stab {stab}\"></span>", stab = stability_class);
+            }
+            document(w, cx, field, Some(it), HeadingOffset::H3);
+        }
+    }
+    let def_id = it.item_id.expect_def_id();
+    render_assoc_items(w, cx, it, def_id, AssocItemRender::All);
+    document_type_layout(w, cx, def_id);
+}
+
+fn print_tuple_struct_fields(w: &mut Buffer, cx: &Context<'_>, s: &[clean::Item]) {
+    for (i, ty) in s.iter().enumerate() {
+        if i > 0 {
+            w.write_str(",&nbsp;");
+        }
+        match *ty.kind {
+            clean::StrippedItem(box clean::StructFieldItem(_)) => w.write_str("_"),
+            clean::StructFieldItem(ref ty) => write!(w, "{}", ty.print(cx)),
+            _ => unreachable!(),
+        }
+    }
+}
+
+fn item_enum(w: &mut Buffer, cx: &mut Context<'_>, it: &clean::Item, e: &clean::Enum) {
+    let count_variants = e.variants().count();
+    wrap_into_docblock(w, |w| {
+        wrap_item(w, "enum", |w| {
+            render_attributes_in_pre(w, it, "");
+            write!(
+                w,
+                "{}enum {}{}",
+                it.visibility.print_with_space(it.item_id, cx),
+                it.name.unwrap(),
+                e.generics.print(cx),
+            );
+            if !print_where_clause_and_check(w, &e.generics, cx) {
+                // If there wasn't a `where` clause, we add a whitespace.
+                w.write_str(" ");
+            }
+
+            let variants_stripped = e.has_stripped_entries();
+            if count_variants == 0 && !variants_stripped {
+                w.write_str("{}");
+            } else {
+                w.write_str("{\n");
+                let toggle = should_hide_fields(count_variants);
+                if toggle {
+                    toggle_open(w, format_args!("{} variants", count_variants));
+                }
+                for v in e.variants() {
+                    w.write_str("    ");
+                    let name = v.name.unwrap();
+                    match *v.kind {
+                        clean::VariantItem(ref var) => match var {
+                            clean::Variant::CLike => write!(w, "{}", name),
+                            clean::Variant::Tuple(ref s) => {
+                                write!(w, "{}(", name);
+                                print_tuple_struct_fields(w, cx, s);
+                                w.write_str(")");
+                            }
+                            clean::Variant::Struct(ref s) => {
+                                render_struct(
+                                    w,
+                                    v,
+                                    None,
+                                    s.struct_type,
+                                    &s.fields,
+                                    "    ",
+                                    false,
+                                    cx,
+                                );
+                            }
+                        },
+                        _ => unreachable!(),
+                    }
+                    w.write_str(",\n");
+                }
+
+                if variants_stripped {
+                    w.write_str("    // some variants omitted\n");
+                }
+                if toggle {
+                    toggle_close(w);
+                }
+                w.write_str("}");
+            }
+        });
+    });
+
+    document(w, cx, it, None, HeadingOffset::H2);
+
+    if count_variants != 0 {
+        write!(
+            w,
+            "<h2 id=\"variants\" class=\"variants small-section-header\">\
+                Variants{}<a href=\"#variants\" class=\"anchor\"></a>\
+            </h2>",
+            document_non_exhaustive_header(it)
+        );
+        document_non_exhaustive(w, it);
+        for variant in e.variants() {
+            let id = cx.derive_id(format!("{}.{}", ItemType::Variant, variant.name.unwrap()));
+            write!(
+                w,
+                "<h3 id=\"{id}\" class=\"variant small-section-header\">\
+                    <a href=\"#{id}\" class=\"anchor field\"></a>\
+                    <code>{name}",
+                id = id,
+                name = variant.name.unwrap()
+            );
+            if let clean::VariantItem(clean::Variant::Tuple(ref s)) = *variant.kind {
+                w.write_str("(");
+                print_tuple_struct_fields(w, cx, s);
+                w.write_str(")");
+            }
+            w.write_str("</code>");
+            render_stability_since(w, variant, it, cx.tcx());
+            w.write_str("</h3>");
+
+            use crate::clean::Variant;
+
+            let heading_and_fields = match &*variant.kind {
+                clean::VariantItem(Variant::Struct(s)) => Some(("Fields", &s.fields)),
+                // Documentation on tuple variant fields is rare, so to reduce noise we only emit
+                // the section if at least one field is documented.
+                clean::VariantItem(Variant::Tuple(fields))
+                    if fields.iter().any(|f| f.doc_value().is_some()) =>
+                {
+                    Some(("Tuple Fields", fields))
+                }
+                _ => None,
+            };
+
+            if let Some((heading, fields)) = heading_and_fields {
+                let variant_id =
+                    cx.derive_id(format!("{}.{}.fields", ItemType::Variant, variant.name.unwrap()));
+                write!(w, "<div class=\"sub-variant\" id=\"{id}\">", id = variant_id);
+                write!(w, "<h4>{heading}</h4>", heading = heading);
+                document_non_exhaustive(w, variant);
+                for field in fields {
+                    match *field.kind {
+                        clean::StrippedItem(box clean::StructFieldItem(_)) => {}
+                        clean::StructFieldItem(ref ty) => {
+                            let id = cx.derive_id(format!(
+                                "variant.{}.field.{}",
+                                variant.name.unwrap(),
+                                field.name.unwrap()
+                            ));
+                            write!(
+                                w,
+                                "<div class=\"sub-variant-field\">\
+                                 <span id=\"{id}\" class=\"variant small-section-header\">\
+                                     <a href=\"#{id}\" class=\"anchor field\"></a>\
+                                     <code>{f}:&nbsp;{t}</code>\
+                                 </span>",
+                                id = id,
+                                f = field.name.unwrap(),
+                                t = ty.print(cx)
+                            );
+                            document(w, cx, field, Some(variant), HeadingOffset::H5);
+                            write!(w, "</div>");
+                        }
+                        _ => unreachable!(),
+                    }
+                }
+                w.write_str("</div>");
+            }
+
+            document(w, cx, variant, Some(it), HeadingOffset::H4);
+        }
+    }
+    let def_id = it.item_id.expect_def_id();
+    render_assoc_items(w, cx, it, def_id, AssocItemRender::All);
+    document_type_layout(w, cx, def_id);
+}
+
+fn item_macro(w: &mut Buffer, cx: &mut Context<'_>, it: &clean::Item, t: &clean::Macro) {
+    wrap_into_docblock(w, |w| {
+        highlight::render_with_highlighting(
+            &t.source,
+            w,
+            Some("macro"),
+            None,
+            None,
+            it.span(cx.tcx()).inner().edition(),
+            None,
+            None,
+            None,
+        );
+    });
+    document(w, cx, it, None, HeadingOffset::H2)
+}
+
+fn item_proc_macro(w: &mut Buffer, cx: &mut Context<'_>, it: &clean::Item, m: &clean::ProcMacro) {
+    wrap_into_docblock(w, |w| {
+        let name = it.name.expect("proc-macros always have names");
+        match m.kind {
+            MacroKind::Bang => {
+                wrap_item(w, "macro", |w| {
+                    write!(w, "{}!() {{ /* proc-macro */ }}", name);
+                });
+            }
+            MacroKind::Attr => {
+                wrap_item(w, "attr", |w| {
+                    write!(w, "#[{}]", name);
+                });
+            }
+            MacroKind::Derive => {
+                wrap_item(w, "derive", |w| {
+                    write!(w, "#[derive({})]", name);
+                    if !m.helpers.is_empty() {
+                        w.push_str("\n{\n");
+                        w.push_str("    // Attributes available to this derive:\n");
+                        for attr in &m.helpers {
+                            writeln!(w, "    #[{}]", attr);
+                        }
+                        w.push_str("}\n");
+                    }
+                });
+            }
+        }
+    });
+    document(w, cx, it, None, HeadingOffset::H2)
+}
+
+fn item_primitive(w: &mut Buffer, cx: &mut Context<'_>, it: &clean::Item) {
+    document(w, cx, it, None, HeadingOffset::H2);
+    render_assoc_items(w, cx, it, it.item_id.expect_def_id(), AssocItemRender::All)
+}
+
+fn item_constant(w: &mut Buffer, cx: &mut Context<'_>, it: &clean::Item, c: &clean::Constant) {
+    wrap_into_docblock(w, |w| {
+        wrap_item(w, "const", |w| {
+            render_attributes_in_code(w, it);
+
+            write!(
+                w,
+                "{vis}const {name}: {typ}",
+                vis = it.visibility.print_with_space(it.item_id, cx),
+                name = it.name.unwrap(),
+                typ = c.type_.print(cx),
+            );
+
+            // FIXME: The code below now prints
+            //            ` = _; // 100i32`
+            //        if the expression is
+            //            `50 + 50`
+            //        which looks just wrong.
+            //        Should we print
+            //            ` = 100i32;`
+            //        instead?
+
+            let value = c.value(cx.tcx());
+            let is_literal = c.is_literal(cx.tcx());
+            let expr = c.expr(cx.tcx());
+            if value.is_some() || is_literal {
+                write!(w, " = {expr};", expr = Escape(&expr));
+            } else {
+                w.write_str(";");
+            }
+
+            if !is_literal {
+                if let Some(value) = &value {
+                    let value_lowercase = value.to_lowercase();
+                    let expr_lowercase = expr.to_lowercase();
+
+                    if value_lowercase != expr_lowercase
+                        && value_lowercase.trim_end_matches("i32") != expr_lowercase
+                    {
+                        write!(w, " // {value}", value = Escape(value));
+                    }
+                }
+            }
+        });
+    });
+
+    document(w, cx, it, None, HeadingOffset::H2)
+}
+
+fn item_struct(w: &mut Buffer, cx: &mut Context<'_>, it: &clean::Item, s: &clean::Struct) {
+    wrap_into_docblock(w, |w| {
+        wrap_item(w, "struct", |w| {
+            render_attributes_in_code(w, it);
+            render_struct(w, it, Some(&s.generics), s.struct_type, &s.fields, "", true, cx);
+        });
+    });
+
+    document(w, cx, it, None, HeadingOffset::H2);
+
+    let mut fields = s
+        .fields
+        .iter()
+        .filter_map(|f| match *f.kind {
+            clean::StructFieldItem(ref ty) => Some((f, ty)),
+            _ => None,
+        })
+        .peekable();
+    if let CtorKind::Fictive | CtorKind::Fn = s.struct_type {
+        if fields.peek().is_some() {
+            write!(
+                w,
+                "<h2 id=\"fields\" class=\"fields small-section-header\">\
+                     {}{}<a href=\"#fields\" class=\"anchor\"></a>\
+                 </h2>",
+                if let CtorKind::Fictive = s.struct_type { "Fields" } else { "Tuple Fields" },
+                document_non_exhaustive_header(it)
+            );
+            document_non_exhaustive(w, it);
+            for (index, (field, ty)) in fields.enumerate() {
+                let field_name =
+                    field.name.map_or_else(|| index.to_string(), |sym| sym.as_str().to_string());
+                let id = cx.derive_id(format!("{}.{}", ItemType::StructField, field_name));
+                write!(
+                    w,
+                    "<span id=\"{id}\" class=\"{item_type} small-section-header\">\
+                         <a href=\"#{id}\" class=\"anchor field\"></a>\
+                         <code>{name}: {ty}</code>\
+                     </span>",
+                    item_type = ItemType::StructField,
+                    id = id,
+                    name = field_name,
+                    ty = ty.print(cx)
+                );
+                document(w, cx, field, Some(it), HeadingOffset::H3);
+            }
+        }
+    }
+    let def_id = it.item_id.expect_def_id();
+    render_assoc_items(w, cx, it, def_id, AssocItemRender::All);
+    document_type_layout(w, cx, def_id);
+}
+
+fn item_static(w: &mut Buffer, cx: &mut Context<'_>, it: &clean::Item, s: &clean::Static) {
+    wrap_into_docblock(w, |w| {
+        wrap_item(w, "static", |w| {
+            render_attributes_in_code(w, it);
+            write!(
+                w,
+                "{vis}static {mutability}{name}: {typ}",
+                vis = it.visibility.print_with_space(it.item_id, cx),
+                mutability = s.mutability.print_with_space(),
+                name = it.name.unwrap(),
+                typ = s.type_.print(cx)
+            );
+        });
+    });
+    document(w, cx, it, None, HeadingOffset::H2)
+}
+
+fn item_foreign_type(w: &mut Buffer, cx: &mut Context<'_>, it: &clean::Item) {
+    wrap_into_docblock(w, |w| {
+        wrap_item(w, "foreigntype", |w| {
+            w.write_str("extern {\n");
+            render_attributes_in_code(w, it);
+            write!(
+                w,
+                "    {}type {};\n}}",
+                it.visibility.print_with_space(it.item_id, cx),
+                it.name.unwrap(),
+            );
+        });
+    });
+
+    document(w, cx, it, None, HeadingOffset::H2);
+
+    render_assoc_items(w, cx, it, it.item_id.expect_def_id(), AssocItemRender::All)
+}
+
+fn item_keyword(w: &mut Buffer, cx: &mut Context<'_>, it: &clean::Item) {
+    document(w, cx, it, None, HeadingOffset::H2)
+}
+
+/// Compare two strings treating multi-digit numbers as single units (i.e. natural sort order).
+pub(crate) fn compare_names(mut lhs: &str, mut rhs: &str) -> Ordering {
+    /// Takes a non-numeric and a numeric part from the given &str.
+    fn take_parts<'a>(s: &mut &'a str) -> (&'a str, &'a str) {
+        let i = s.find(|c: char| c.is_ascii_digit());
+        let (a, b) = s.split_at(i.unwrap_or(s.len()));
+        let i = b.find(|c: char| !c.is_ascii_digit());
+        let (b, c) = b.split_at(i.unwrap_or(b.len()));
+        *s = c;
+        (a, b)
+    }
+
+    while !lhs.is_empty() || !rhs.is_empty() {
+        let (la, lb) = take_parts(&mut lhs);
+        let (ra, rb) = take_parts(&mut rhs);
+        // First process the non-numeric part.
+        match la.cmp(ra) {
+            Ordering::Equal => (),
+            x => return x,
+        }
+        // Then process the numeric part, if both sides have one (and they fit in a u64).
+        if let (Ok(ln), Ok(rn)) = (lb.parse::<u64>(), rb.parse::<u64>()) {
+            match ln.cmp(&rn) {
+                Ordering::Equal => (),
+                x => return x,
+            }
+        }
+        // Then process the numeric part again, but this time as strings.
+        match lb.cmp(rb) {
+            Ordering::Equal => (),
+            x => return x,
+        }
+    }
+
+    Ordering::Equal
+}
+
+pub(super) fn full_path(cx: &Context<'_>, item: &clean::Item) -> String {
+    let mut s = join_with_double_colon(&cx.current);
+    s.push_str("::");
+    s.push_str(item.name.unwrap().as_str());
+    s
+}
+
+pub(super) fn item_path(ty: ItemType, name: &str) -> String {
+    match ty {
+        ItemType::Module => format!("{}index.html", ensure_trailing_slash(name)),
+        _ => format!("{}.{}.html", ty, name),
+    }
+}
+
+fn bounds(t_bounds: &[clean::GenericBound], trait_alias: bool, cx: &Context<'_>) -> String {
+    let mut bounds = String::new();
+    if !t_bounds.is_empty() {
+        if !trait_alias {
+            bounds.push_str(": ");
+        }
+        for (i, p) in t_bounds.iter().enumerate() {
+            if i > 0 {
+                bounds.push_str(" + ");
+            }
+            bounds.push_str(&p.print(cx).to_string());
+        }
+    }
+    bounds
+}
+
+fn wrap_into_docblock<F>(w: &mut Buffer, f: F)
+where
+    F: FnOnce(&mut Buffer),
+{
+    w.write_str("<div class=\"docblock item-decl\">");
+    f(w);
+    w.write_str("</div>")
+}
+
+fn wrap_item<F>(w: &mut Buffer, item_name: &str, f: F)
+where
+    F: FnOnce(&mut Buffer),
+{
+    w.write_fmt(format_args!("<pre class=\"rust {}\"><code>", item_name));
+    f(w);
+    w.write_str("</code></pre>");
+}
+
+fn render_stability_since(
+    w: &mut Buffer,
+    item: &clean::Item,
+    containing_item: &clean::Item,
+    tcx: TyCtxt<'_>,
+) -> bool {
+    render_stability_since_raw(
+        w,
+        item.stable_since(tcx),
+        item.const_stability(tcx),
+        containing_item.stable_since(tcx),
+        containing_item.const_stable_since(tcx),
+    )
+}
+
+fn compare_impl<'a, 'b>(lhs: &'a &&Impl, rhs: &'b &&Impl, cx: &Context<'_>) -> Ordering {
+    let lhss = format!("{}", lhs.inner_impl().print(false, cx));
+    let rhss = format!("{}", rhs.inner_impl().print(false, cx));
+
+    // lhs and rhs are formatted as HTML, which may be unnecessary
+    compare_names(&lhss, &rhss)
+}
+
+fn render_implementor(
+    cx: &mut Context<'_>,
+    implementor: &Impl,
+    trait_: &clean::Item,
+    w: &mut Buffer,
+    implementor_dups: &FxHashMap<Symbol, (DefId, bool)>,
+    aliases: &[String],
+) {
+    // If there's already another implementor that has the same abridged name, use the
+    // full path, for example in `std::iter::ExactSizeIterator`
+    let use_absolute = match implementor.inner_impl().for_ {
+        clean::Type::Path { ref path, .. }
+        | clean::BorrowedRef { type_: box clean::Type::Path { ref path, .. }, .. }
+            if !path.is_assoc_ty() =>
+        {
+            implementor_dups[&path.last()].1
+        }
+        _ => false,
+    };
+    render_impl(
+        w,
+        cx,
+        implementor,
+        trait_,
+        AssocItemLink::Anchor(None),
+        RenderMode::Normal,
+        Some(use_absolute),
+        aliases,
+        ImplRenderingParameters {
+            show_def_docs: false,
+            show_default_items: false,
+            show_non_assoc_items: false,
+            toggle_open_by_default: false,
+        },
+    );
+}
+
+fn render_union(
+    w: &mut Buffer,
+    it: &clean::Item,
+    g: Option<&clean::Generics>,
+    fields: &[clean::Item],
+    tab: &str,
+    cx: &Context<'_>,
+) {
+    write!(w, "{}union {}", it.visibility.print_with_space(it.item_id, cx), it.name.unwrap(),);
+
+    let where_displayed = g
+        .map(|g| {
+            write!(w, "{}", g.print(cx));
+            print_where_clause_and_check(w, g, cx)
+        })
+        .unwrap_or(false);
+
+    // If there wasn't a `where` clause, we add a whitespace.
+    if !where_displayed {
+        w.write_str(" ");
+    }
+
+    write!(w, "{{\n{}", tab);
+    let count_fields =
+        fields.iter().filter(|f| matches!(*f.kind, clean::StructFieldItem(..))).count();
+    let toggle = should_hide_fields(count_fields);
+    if toggle {
+        toggle_open(w, format_args!("{} fields", count_fields));
+    }
+
+    for field in fields {
+        if let clean::StructFieldItem(ref ty) = *field.kind {
+            write!(
+                w,
+                "    {}{}: {},\n{}",
+                field.visibility.print_with_space(field.item_id, cx),
+                field.name.unwrap(),
+                ty.print(cx),
+                tab
+            );
+        }
+    }
+
+    if it.has_stripped_entries().unwrap() {
+        write!(w, "    /* private fields */\n{}", tab);
+    }
+    if toggle {
+        toggle_close(w);
+    }
+    w.write_str("}");
+}
+
+fn render_struct(
+    w: &mut Buffer,
+    it: &clean::Item,
+    g: Option<&clean::Generics>,
+    ty: CtorKind,
+    fields: &[clean::Item],
+    tab: &str,
+    structhead: bool,
+    cx: &Context<'_>,
+) {
+    write!(
+        w,
+        "{}{}{}",
+        it.visibility.print_with_space(it.item_id, cx),
+        if structhead { "struct " } else { "" },
+        it.name.unwrap()
+    );
+    if let Some(g) = g {
+        write!(w, "{}", g.print(cx))
+    }
+    match ty {
+        CtorKind::Fictive => {
+            let where_diplayed = g.map(|g| print_where_clause_and_check(w, g, cx)).unwrap_or(false);
+
+            // If there wasn't a `where` clause, we add a whitespace.
+            if !where_diplayed {
+                w.write_str(" {");
+            } else {
+                w.write_str("{");
+            }
+            let count_fields =
+                fields.iter().filter(|f| matches!(*f.kind, clean::StructFieldItem(..))).count();
+            let has_visible_fields = count_fields > 0;
+            let toggle = should_hide_fields(count_fields);
+            if toggle {
+                toggle_open(w, format_args!("{} fields", count_fields));
+            }
+            for field in fields {
+                if let clean::StructFieldItem(ref ty) = *field.kind {
+                    write!(
+                        w,
+                        "\n{}    {}{}: {},",
+                        tab,
+                        field.visibility.print_with_space(field.item_id, cx),
+                        field.name.unwrap(),
+                        ty.print(cx),
+                    );
+                }
+            }
+
+            if has_visible_fields {
+                if it.has_stripped_entries().unwrap() {
+                    write!(w, "\n{}    /* private fields */", tab);
+                }
+                write!(w, "\n{}", tab);
+            } else if it.has_stripped_entries().unwrap() {
+                write!(w, " /* private fields */ ");
+            }
+            if toggle {
+                toggle_close(w);
+            }
+            w.write_str("}");
+        }
+        CtorKind::Fn => {
+            w.write_str("(");
+            for (i, field) in fields.iter().enumerate() {
+                if i > 0 {
+                    w.write_str(", ");
+                }
+                match *field.kind {
+                    clean::StrippedItem(box clean::StructFieldItem(..)) => write!(w, "_"),
+                    clean::StructFieldItem(ref ty) => {
+                        write!(
+                            w,
+                            "{}{}",
+                            field.visibility.print_with_space(field.item_id, cx),
+                            ty.print(cx),
+                        )
+                    }
+                    _ => unreachable!(),
+                }
+            }
+            w.write_str(")");
+            if let Some(g) = g {
+                write!(w, "{}", print_where_clause(g, cx, 0, Ending::NoNewline));
+            }
+            // We only want a ";" when we are displaying a tuple struct, not a variant tuple struct.
+            if structhead {
+                w.write_str(";");
+            }
+        }
+        CtorKind::Const => {
+            // Needed for PhantomData.
+            if let Some(g) = g {
+                write!(w, "{}", print_where_clause(g, cx, 0, Ending::NoNewline));
+            }
+            w.write_str(";");
+        }
+    }
+}
+
+fn document_non_exhaustive_header(item: &clean::Item) -> &str {
+    if item.is_non_exhaustive() { " (Non-exhaustive)" } else { "" }
+}
+
+fn document_non_exhaustive(w: &mut Buffer, item: &clean::Item) {
+    if item.is_non_exhaustive() {
+        write!(
+            w,
+            "<details class=\"rustdoc-toggle non-exhaustive\">\
+                 <summary class=\"hideme\"><span>{}</span></summary>\
+                 <div class=\"docblock\">",
+            {
+                if item.is_struct() {
+                    "This struct is marked as non-exhaustive"
+                } else if item.is_enum() {
+                    "This enum is marked as non-exhaustive"
+                } else if item.is_variant() {
+                    "This variant is marked as non-exhaustive"
+                } else {
+                    "This type is marked as non-exhaustive"
+                }
+            }
+        );
+
+        if item.is_struct() {
+            w.write_str(
+                "Non-exhaustive structs could have additional fields added in future. \
+                 Therefore, non-exhaustive structs cannot be constructed in external crates \
+                 using the traditional <code>Struct { .. }</code> syntax; cannot be \
+                 matched against without a wildcard <code>..</code>; and \
+                 struct update syntax will not work.",
+            );
+        } else if item.is_enum() {
+            w.write_str(
+                "Non-exhaustive enums could have additional variants added in future. \
+                 Therefore, when matching against variants of non-exhaustive enums, an \
+                 extra wildcard arm must be added to account for any future variants.",
+            );
+        } else if item.is_variant() {
+            w.write_str(
+                "Non-exhaustive enum variants could have additional fields added in future. \
+                 Therefore, non-exhaustive enum variants cannot be constructed in external \
+                 crates and cannot be matched against.",
+            );
+        } else {
+            w.write_str(
+                "This type will require a wildcard arm in any match statements or constructors.",
+            );
+        }
+
+        w.write_str("</div></details>");
+    }
+}
+
+fn document_type_layout(w: &mut Buffer, cx: &Context<'_>, ty_def_id: DefId) {
+    fn write_size_of_layout(w: &mut Buffer, layout: Layout<'_>, tag_size: u64) {
+        if layout.abi().is_unsized() {
+            write!(w, "(unsized)");
+        } else {
+            let bytes = layout.size().bytes() - tag_size;
+            write!(w, "{size} byte{pl}", size = bytes, pl = if bytes == 1 { "" } else { "s" },);
+        }
+    }
+
+    if !cx.shared.show_type_layout {
+        return;
+    }
+
+    writeln!(
+        w,
+        "<h2 id=\"layout\" class=\"small-section-header\"> \
+        Layout<a href=\"#layout\" class=\"anchor\"></a></h2>"
+    );
+    writeln!(w, "<div class=\"docblock\">");
+
+    let tcx = cx.tcx();
+    let param_env = tcx.param_env(ty_def_id);
+    let ty = tcx.type_of(ty_def_id);
+    match tcx.layout_of(param_env.and(ty)) {
+        Ok(ty_layout) => {
+            writeln!(
+                w,
+                "<div class=\"warning\"><p><strong>Note:</strong> Most layout information is \
+                 <strong>completely unstable</strong> and may even differ between compilations. \
+                 The only exception is types with certain <code>repr(...)</code> attributes. \
+                 Please see the Rust Reference’s \
+                 <a href=\"https://doc.rust-lang.org/reference/type-layout.html\">“Type Layout”</a> \
+                 chapter for details on type layout guarantees.</p></div>"
+            );
+            w.write_str("<p><strong>Size:</strong> ");
+            write_size_of_layout(w, ty_layout.layout, 0);
+            writeln!(w, "</p>");
+            if let Variants::Multiple { variants, tag, tag_encoding, .. } =
+                &ty_layout.layout.variants()
+            {
+                if !variants.is_empty() {
+                    w.write_str(
+                        "<p><strong>Size for each variant:</strong></p>\
+                            <ul>",
+                    );
+
+                    let Adt(adt, _) = ty_layout.ty.kind() else {
+                        span_bug!(tcx.def_span(ty_def_id), "not an adt")
+                    };
+
+                    let tag_size = if let TagEncoding::Niche { .. } = tag_encoding {
+                        0
+                    } else if let Primitive::Int(i, _) = tag.primitive() {
+                        i.size().bytes()
+                    } else {
+                        span_bug!(tcx.def_span(ty_def_id), "tag is neither niche nor int")
+                    };
+
+                    for (index, layout) in variants.iter_enumerated() {
+                        let name = adt.variant(index).name;
+                        write!(w, "<li><code>{name}</code>: ", name = name);
+                        write_size_of_layout(w, *layout, tag_size);
+                        writeln!(w, "</li>");
+                    }
+                    w.write_str("</ul>");
+                }
+            }
+        }
+        // This kind of layout error can occur with valid code, e.g. if you try to
+        // get the layout of a generic type such as `Vec<T>`.
+        Err(LayoutError::Unknown(_)) => {
+            writeln!(
+                w,
+                "<p><strong>Note:</strong> Unable to compute type layout, \
+                 possibly due to this type having generic parameters. \
+                 Layout can only be computed for concrete, fully-instantiated types.</p>"
+            );
+        }
+        // This kind of error probably can't happen with valid code, but we don't
+        // want to panic and prevent the docs from building, so we just let the
+        // user know that we couldn't compute the layout.
+        Err(LayoutError::SizeOverflow(_)) => {
+            writeln!(
+                w,
+                "<p><strong>Note:</strong> Encountered an error during type layout; \
+                 the type was too big.</p>"
+            );
+        }
+        Err(LayoutError::NormalizationFailure(_, _)) => {
+            writeln!(
+                w,
+                "<p><strong>Note:</strong> Encountered an error during type layout; \
+                the type failed to be normalized.</p>"
+            )
+        }
+    }
+
+    writeln!(w, "</div>");
+}
+
+fn pluralize(count: usize) -> &'static str {
+    if count > 1 { "s" } else { "" }
+}
diff --git a/src/librustdoc/html/render/search_index.rs b/src/librustdoc/html/render/search_index.rs
new file mode 100644
index 000000000..d672f0bb5
--- /dev/null
+++ b/src/librustdoc/html/render/search_index.rs
@@ -0,0 +1,589 @@
+use std::collections::hash_map::Entry;
+use std::collections::BTreeMap;
+
+use rustc_data_structures::fx::FxHashMap;
+use rustc_middle::ty::TyCtxt;
+use rustc_span::def_id::LOCAL_CRATE;
+use rustc_span::symbol::Symbol;
+use serde::ser::{Serialize, SerializeStruct, Serializer};
+
+use crate::clean;
+use crate::clean::types::{
+    FnRetTy, Function, GenericBound, Generics, ItemId, Type, WherePredicate,
+};
+use crate::formats::cache::{Cache, OrphanImplItem};
+use crate::formats::item_type::ItemType;
+use crate::html::format::join_with_double_colon;
+use crate::html::markdown::short_markdown_summary;
+use crate::html::render::{IndexItem, IndexItemFunctionType, RenderType, RenderTypeId};
+
+/// Builds the search index from the collected metadata
+pub(crate) fn build_index<'tcx>(
+    krate: &clean::Crate,
+    cache: &mut Cache,
+    tcx: TyCtxt<'tcx>,
+) -> String {
+    let mut itemid_to_pathid = FxHashMap::default();
+    let mut crate_paths = vec![];
+
+    // Attach all orphan items to the type's definition if the type
+    // has since been learned.
+    for &OrphanImplItem { parent, ref item, ref impl_generics } in &cache.orphan_impl_items {
+        if let Some(&(ref fqp, _)) = cache.paths.get(&parent) {
+            let desc = item
+                .doc_value()
+                .map_or_else(String::new, |s| short_markdown_summary(&s, &item.link_names(cache)));
+            cache.search_index.push(IndexItem {
+                ty: item.type_(),
+                name: item.name.unwrap().to_string(),
+                path: join_with_double_colon(&fqp[..fqp.len() - 1]),
+                desc,
+                parent: Some(parent),
+                parent_idx: None,
+                search_type: get_function_type_for_search(item, tcx, impl_generics.as_ref(), cache),
+                aliases: item.attrs.get_doc_aliases(),
+            });
+        }
+    }
+
+    let crate_doc = krate
+        .module
+        .doc_value()
+        .map_or_else(String::new, |s| short_markdown_summary(&s, &krate.module.link_names(cache)));
+
+    // Aliases added through `#[doc(alias = "...")]`. Since a few items can have the same alias,
+    // we need the alias element to have an array of items.
+    let mut aliases: BTreeMap<String, Vec<usize>> = BTreeMap::new();
+
+    // Sort search index items. This improves the compressibility of the search index.
+    cache.search_index.sort_unstable_by(|k1, k2| {
+        // `sort_unstable_by_key` produces lifetime errors
+        let k1 = (&k1.path, &k1.name, &k1.ty, &k1.parent);
+        let k2 = (&k2.path, &k2.name, &k2.ty, &k2.parent);
+        std::cmp::Ord::cmp(&k1, &k2)
+    });
+
+    // Set up alias indexes.
+    for (i, item) in cache.search_index.iter().enumerate() {
+        for alias in &item.aliases[..] {
+            aliases.entry(alias.as_str().to_lowercase()).or_default().push(i);
+        }
+    }
+
+    // Reduce `DefId` in paths into smaller sequential numbers,
+    // and prune the paths that do not appear in the index.
+    let mut lastpath = "";
+    let mut lastpathid = 0usize;
+
+    // First, on function signatures
+    let mut search_index = std::mem::replace(&mut cache.search_index, Vec::new());
+    for item in search_index.iter_mut() {
+        fn convert_render_type(
+            ty: &mut RenderType,
+            cache: &mut Cache,
+            itemid_to_pathid: &mut FxHashMap<ItemId, usize>,
+            lastpathid: &mut usize,
+            crate_paths: &mut Vec<(ItemType, Symbol)>,
+        ) {
+            if let Some(generics) = &mut ty.generics {
+                for item in generics {
+                    convert_render_type(item, cache, itemid_to_pathid, lastpathid, crate_paths);
+                }
+            }
+            let Cache { ref paths, ref external_paths, .. } = *cache;
+            let Some(id) = ty.id.clone() else {
+                assert!(ty.generics.is_some());
+                return;
+            };
+            let (itemid, path, item_type) = match id {
+                RenderTypeId::DefId(defid) => {
+                    if let Some(&(ref fqp, item_type)) =
+                        paths.get(&defid).or_else(|| external_paths.get(&defid))
+                    {
+                        (ItemId::DefId(defid), *fqp.last().unwrap(), item_type)
+                    } else {
+                        ty.id = None;
+                        return;
+                    }
+                }
+                RenderTypeId::Primitive(primitive) => (
+                    ItemId::Primitive(primitive, LOCAL_CRATE),
+                    primitive.as_sym(),
+                    ItemType::Primitive,
+                ),
+                RenderTypeId::Index(_) => return,
+            };
+            match itemid_to_pathid.entry(itemid) {
+                Entry::Occupied(entry) => ty.id = Some(RenderTypeId::Index(*entry.get())),
+                Entry::Vacant(entry) => {
+                    let pathid = *lastpathid;
+                    entry.insert(pathid);
+                    *lastpathid += 1;
+                    crate_paths.push((item_type, path));
+                    ty.id = Some(RenderTypeId::Index(pathid));
+                }
+            }
+        }
+        if let Some(search_type) = &mut item.search_type {
+            for item in &mut search_type.inputs {
+                convert_render_type(
+                    item,
+                    cache,
+                    &mut itemid_to_pathid,
+                    &mut lastpathid,
+                    &mut crate_paths,
+                );
+            }
+            for item in &mut search_type.output {
+                convert_render_type(
+                    item,
+                    cache,
+                    &mut itemid_to_pathid,
+                    &mut lastpathid,
+                    &mut crate_paths,
+                );
+            }
+        }
+    }
+
+    let Cache { ref paths, .. } = *cache;
+
+    // Then, on parent modules
+    let crate_items: Vec<&IndexItem> = search_index
+        .iter_mut()
+        .map(|item| {
+            item.parent_idx =
+                item.parent.and_then(|defid| match itemid_to_pathid.entry(ItemId::DefId(defid)) {
+                    Entry::Occupied(entry) => Some(*entry.get()),
+                    Entry::Vacant(entry) => {
+                        let pathid = lastpathid;
+                        entry.insert(pathid);
+                        lastpathid += 1;
+
+                        if let Some(&(ref fqp, short)) = paths.get(&defid) {
+                            crate_paths.push((short, *fqp.last().unwrap()));
+                            Some(pathid)
+                        } else {
+                            None
+                        }
+                    }
+                });
+
+            // Omit the parent path if it is same to that of the prior item.
+            if lastpath == &item.path {
+                item.path.clear();
+            } else {
+                lastpath = &item.path;
+            }
+
+            &*item
+        })
+        .collect();
+
+    struct CrateData<'a> {
+        doc: String,
+        items: Vec<&'a IndexItem>,
+        paths: Vec<(ItemType, Symbol)>,
+        // The String is alias name and the vec is the list of the elements with this alias.
+        //
+        // To be noted: the `usize` elements are indexes to `items`.
+        aliases: &'a BTreeMap<String, Vec<usize>>,
+    }
+
+    impl<'a> Serialize for CrateData<'a> {
+        fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+        where
+            S: Serializer,
+        {
+            let has_aliases = !self.aliases.is_empty();
+            let mut crate_data =
+                serializer.serialize_struct("CrateData", if has_aliases { 9 } else { 8 })?;
+            crate_data.serialize_field("doc", &self.doc)?;
+            crate_data.serialize_field(
+                "t",
+                &self.items.iter().map(|item| &item.ty).collect::<Vec<_>>(),
+            )?;
+            crate_data.serialize_field(
+                "n",
+                &self.items.iter().map(|item| &item.name).collect::<Vec<_>>(),
+            )?;
+            crate_data.serialize_field(
+                "q",
+                &self.items.iter().map(|item| &item.path).collect::<Vec<_>>(),
+            )?;
+            crate_data.serialize_field(
+                "d",
+                &self.items.iter().map(|item| &item.desc).collect::<Vec<_>>(),
+            )?;
+            crate_data.serialize_field(
+                "i",
+                &self
+                    .items
+                    .iter()
+                    .map(|item| {
+                        assert_eq!(
+                            item.parent.is_some(),
+                            item.parent_idx.is_some(),
+                            "`{}` is missing idx",
+                            item.name
+                        );
+                        // 0 is a sentinel, everything else is one-indexed
+                        item.parent_idx.map(|x| x + 1).unwrap_or(0)
+                    })
+                    .collect::<Vec<_>>(),
+            )?;
+            crate_data.serialize_field(
+                "f",
+                &self
+                    .items
+                    .iter()
+                    .map(|item| {
+                        // Fake option to get `0` out as a sentinel instead of `null`.
+                        // We want to use `0` because it's three less bytes.
+                        enum FunctionOption<'a> {
+                            Function(&'a IndexItemFunctionType),
+                            None,
+                        }
+                        impl<'a> Serialize for FunctionOption<'a> {
+                            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+                            where
+                                S: Serializer,
+                            {
+                                match self {
+                                    FunctionOption::None => 0.serialize(serializer),
+                                    FunctionOption::Function(ty) => ty.serialize(serializer),
+                                }
+                            }
+                        }
+                        match &item.search_type {
+                            Some(ty) => FunctionOption::Function(ty),
+                            None => FunctionOption::None,
+                        }
+                    })
+                    .collect::<Vec<_>>(),
+            )?;
+            crate_data.serialize_field(
+                "p",
+                &self.paths.iter().map(|(it, s)| (it, s.to_string())).collect::<Vec<_>>(),
+            )?;
+            if has_aliases {
+                crate_data.serialize_field("a", &self.aliases)?;
+            }
+            crate_data.end()
+        }
+    }
+
+    // Collect the index into a string
+    format!(
+        r#""{}":{}"#,
+        krate.name(tcx),
+        serde_json::to_string(&CrateData {
+            doc: crate_doc,
+            items: crate_items,
+            paths: crate_paths,
+            aliases: &aliases,
+        })
+        .expect("failed serde conversion")
+        // All these `replace` calls are because we have to go through JS string for JSON content.
+        .replace('\\', r"\\")
+        .replace('\'', r"\'")
+        // We need to escape double quotes for the JSON.
+        .replace("\\\"", "\\\\\"")
+    )
+}
+
+pub(crate) fn get_function_type_for_search<'tcx>(
+    item: &clean::Item,
+    tcx: TyCtxt<'tcx>,
+    impl_generics: Option<&(clean::Type, clean::Generics)>,
+    cache: &Cache,
+) -> Option<IndexItemFunctionType> {
+    let (mut inputs, mut output) = match *item.kind {
+        clean::FunctionItem(ref f) => get_fn_inputs_and_outputs(f, tcx, impl_generics, cache),
+        clean::MethodItem(ref m, _) => get_fn_inputs_and_outputs(m, tcx, impl_generics, cache),
+        clean::TyMethodItem(ref m) => get_fn_inputs_and_outputs(m, tcx, impl_generics, cache),
+        _ => return None,
+    };
+
+    inputs.retain(|a| a.id.is_some() || a.generics.is_some());
+    output.retain(|a| a.id.is_some() || a.generics.is_some());
+
+    Some(IndexItemFunctionType { inputs, output })
+}
+
+fn get_index_type(clean_type: &clean::Type, generics: Vec<RenderType>) -> RenderType {
+    RenderType {
+        id: get_index_type_id(clean_type),
+        generics: if generics.is_empty() { None } else { Some(generics) },
+    }
+}
+
+fn get_index_type_id(clean_type: &clean::Type) -> Option<RenderTypeId> {
+    match *clean_type {
+        clean::Type::Path { ref path, .. } => Some(RenderTypeId::DefId(path.def_id())),
+        clean::DynTrait(ref bounds, _) => {
+            let path = &bounds[0].trait_;
+            Some(RenderTypeId::DefId(path.def_id()))
+        }
+        clean::Primitive(p) => Some(RenderTypeId::Primitive(p)),
+        clean::BorrowedRef { ref type_, .. } | clean::RawPointer(_, ref type_) => {
+            get_index_type_id(type_)
+        }
+        clean::BareFunction(_)
+        | clean::Generic(_)
+        | clean::ImplTrait(_)
+        | clean::Tuple(_)
+        | clean::Slice(_)
+        | clean::Array(_, _)
+        | clean::QPath { .. }
+        | clean::Infer => None,
+    }
+}
+
+/// The point of this function is to replace bounds with types.
+///
+/// i.e. `[T, U]` when you have the following bounds: `T: Display, U: Option<T>` will return
+/// `[Display, Option]`. If a type parameter has no trait bound, it is discarded.
+///
+/// Important note: It goes through generics recursively. So if you have
+/// `T: Option<Result<(), ()>>`, it'll go into `Option` and then into `Result`.
+#[instrument(level = "trace", skip(tcx, res, cache))]
+fn add_generics_and_bounds_as_types<'tcx, 'a>(
+    self_: Option<&'a Type>,
+    generics: &Generics,
+    arg: &'a Type,
+    tcx: TyCtxt<'tcx>,
+    recurse: usize,
+    res: &mut Vec<RenderType>,
+    cache: &Cache,
+) {
+    fn insert_ty(res: &mut Vec<RenderType>, ty: Type, mut generics: Vec<RenderType>) {
+        // generics and impl trait are both identified by their generics,
+        // rather than a type name itself
+        let anonymous = ty.is_full_generic() || ty.is_impl_trait();
+        let generics_empty = generics.is_empty();
+
+        if anonymous {
+            if generics_empty {
+                // This is a type parameter with no trait bounds (for example: `T` in
+                // `fn f<T>(p: T)`, so not useful for the rustdoc search because we would end up
+                // with an empty type with an empty name. Let's just discard it.
+                return;
+            } else if generics.len() == 1 {
+                // In this case, no need to go through an intermediate state if the type parameter
+                // contains only one trait bound.
+                //
+                // For example:
+                //
+                // `fn foo<T: Display>(r: Option<T>) {}`
+                //
+                // In this case, it would contain:
+                //
+                // ```
+                // [{
+                //     name: "option",
+                //     generics: [{
+                //         name: "",
+                //         generics: [
+                //             name: "Display",
+                //             generics: []
+                //         }]
+                //     }]
+                // }]
+                // ```
+                //
+                // After removing the intermediate (unnecessary) type parameter, it'll become:
+                //
+                // ```
+                // [{
+                //     name: "option",
+                //     generics: [{
+                //         name: "Display",
+                //         generics: []
+                //     }]
+                // }]
+                // ```
+                //
+                // To be noted that it can work if there is ONLY ONE trait bound, otherwise we still
+                // need to keep it as is!
+                res.push(generics.pop().unwrap());
+                return;
+            }
+        }
+        let index_ty = get_index_type(&ty, generics);
+        if index_ty.id.is_none() && generics_empty {
+            return;
+        }
+        res.push(index_ty);
+    }
+
+    if recurse >= 10 {
+        // FIXME: remove this whole recurse thing when the recursion bug is fixed
+        // See #59502 for the original issue.
+        return;
+    }
+
+    // First, check if it's "Self".
+    let arg = if let Some(self_) = self_ {
+        match &*arg {
+            Type::BorrowedRef { type_, .. } if type_.is_self_type() => self_,
+            type_ if type_.is_self_type() => self_,
+            arg => arg,
+        }
+    } else {
+        arg
+    };
+
+    // If this argument is a type parameter and not a trait bound or a type, we need to look
+    // for its bounds.
+    if let Type::Generic(arg_s) = *arg {
+        // First we check if the bounds are in a `where` predicate...
+        if let Some(where_pred) = generics.where_predicates.iter().find(|g| match g {
+            WherePredicate::BoundPredicate { ty, .. } => ty.def_id(cache) == arg.def_id(cache),
+            _ => false,
+        }) {
+            let mut ty_generics = Vec::new();
+            let bounds = where_pred.get_bounds().unwrap_or_else(|| &[]);
+            for bound in bounds.iter() {
+                if let GenericBound::TraitBound(poly_trait, _) = bound {
+                    for param_def in poly_trait.generic_params.iter() {
+                        match &param_def.kind {
+                            clean::GenericParamDefKind::Type { default: Some(ty), .. } => {
+                                add_generics_and_bounds_as_types(
+                                    self_,
+                                    generics,
+                                    ty,
+                                    tcx,
+                                    recurse + 1,
+                                    &mut ty_generics,
+                                    cache,
+                                )
+                            }
+                            _ => {}
+                        }
+                    }
+                }
+            }
+            insert_ty(res, arg.clone(), ty_generics);
+        }
+        // Otherwise we check if the trait bounds are "inlined" like `T: Option<u32>`...
+        if let Some(bound) = generics.params.iter().find(|g| g.is_type() && g.name == arg_s) {
+            let mut ty_generics = Vec::new();
+            for bound in bound.get_bounds().unwrap_or(&[]) {
+                if let Some(path) = bound.get_trait_path() {
+                    let ty = Type::Path { path };
+                    add_generics_and_bounds_as_types(
+                        self_,
+                        generics,
+                        &ty,
+                        tcx,
+                        recurse + 1,
+                        &mut ty_generics,
+                        cache,
+                    );
+                }
+            }
+            insert_ty(res, arg.clone(), ty_generics);
+        }
+    } else if let Type::ImplTrait(ref bounds) = *arg {
+        let mut ty_generics = Vec::new();
+        for bound in bounds {
+            if let Some(path) = bound.get_trait_path() {
+                let ty = Type::Path { path };
+                add_generics_and_bounds_as_types(
+                    self_,
+                    generics,
+                    &ty,
+                    tcx,
+                    recurse + 1,
+                    &mut ty_generics,
+                    cache,
+                );
+            }
+        }
+        insert_ty(res, arg.clone(), ty_generics);
+    } else {
+        // This is not a type parameter. So for example if we have `T, U: Option<T>`, and we're
+        // looking at `Option`, we enter this "else" condition, otherwise if it's `T`, we don't.
+        //
+        // So in here, we can add it directly and look for its own type parameters (so for `Option`,
+        // we will look for them but not for `T`).
+        let mut ty_generics = Vec::new();
+        if let Some(arg_generics) = arg.generics() {
+            for gen in arg_generics.iter() {
+                add_generics_and_bounds_as_types(
+                    self_,
+                    generics,
+                    gen,
+                    tcx,
+                    recurse + 1,
+                    &mut ty_generics,
+                    cache,
+                );
+            }
+        }
+        insert_ty(res, arg.clone(), ty_generics);
+    }
+}
+
+/// Return the full list of types when bounds have been resolved.
+///
+/// i.e. `fn foo<A: Display, B: Option<A>>(x: u32, y: B)` will return
+/// `[u32, Display, Option]`.
+fn get_fn_inputs_and_outputs<'tcx>(
+    func: &Function,
+    tcx: TyCtxt<'tcx>,
+    impl_generics: Option<&(clean::Type, clean::Generics)>,
+    cache: &Cache,
+) -> (Vec<RenderType>, Vec<RenderType>) {
+    let decl = &func.decl;
+
+    let combined_generics;
+    let (self_, generics) = if let Some(&(ref impl_self, ref impl_generics)) = impl_generics {
+        match (impl_generics.is_empty(), func.generics.is_empty()) {
+            (true, _) => (Some(impl_self), &func.generics),
+            (_, true) => (Some(impl_self), impl_generics),
+            (false, false) => {
+                let mut params = func.generics.params.clone();
+                params.extend(impl_generics.params.clone());
+                let mut where_predicates = func.generics.where_predicates.clone();
+                where_predicates.extend(impl_generics.where_predicates.clone());
+                combined_generics = clean::Generics { params, where_predicates };
+                (Some(impl_self), &combined_generics)
+            }
+        }
+    } else {
+        (None, &func.generics)
+    };
+
+    let mut all_types = Vec::new();
+    for arg in decl.inputs.values.iter() {
+        let mut args = Vec::new();
+        add_generics_and_bounds_as_types(self_, generics, &arg.type_, tcx, 0, &mut args, cache);
+        if !args.is_empty() {
+            all_types.extend(args);
+        } else {
+            all_types.push(get_index_type(&arg.type_, vec![]));
+        }
+    }
+
+    let mut ret_types = Vec::new();
+    match decl.output {
+        FnRetTy::Return(ref return_type) => {
+            add_generics_and_bounds_as_types(
+                self_,
+                generics,
+                return_type,
+                tcx,
+                0,
+                &mut ret_types,
+                cache,
+            );
+            if ret_types.is_empty() {
+                ret_types.push(get_index_type(return_type, vec![]));
+            }
+        }
+        _ => {}
+    };
+    (all_types, ret_types)
+}
diff --git a/src/librustdoc/html/render/span_map.rs b/src/librustdoc/html/render/span_map.rs
new file mode 100644
index 000000000..34d590fb2
--- /dev/null
+++ b/src/librustdoc/html/render/span_map.rs
@@ -0,0 +1,203 @@
+use crate::clean::{self, PrimitiveType};
+use crate::html::sources;
+
+use rustc_data_structures::fx::FxHashMap;
+use rustc_hir::def::{DefKind, Res};
+use rustc_hir::def_id::DefId;
+use rustc_hir::intravisit::{self, Visitor};
+use rustc_hir::{ExprKind, HirId, Mod, Node};
+use rustc_middle::hir::nested_filter;
+use rustc_middle::ty::TyCtxt;
+use rustc_span::hygiene::MacroKind;
+use rustc_span::{BytePos, ExpnKind, Span};
+
+use std::path::{Path, PathBuf};
+
+/// This enum allows us to store two different kinds of information:
+///
+/// In case the `span` definition comes from the same crate, we can simply get the `span` and use
+/// it as is.
+///
+/// Otherwise, we store the definition `DefId` and will generate a link to the documentation page
+/// instead of the source code directly.
+#[derive(Debug)]
+pub(crate) enum LinkFromSrc {
+    Local(clean::Span),
+    External(DefId),
+    Primitive(PrimitiveType),
+}
+
+/// This function will do at most two things:
+///
+/// 1. Generate a `span` correspondance map which links an item `span` to its definition `span`.
+/// 2. Collect the source code files.
+///
+/// It returns the `krate`, the source code files and the `span` correspondance map.
+///
+/// Note about the `span` correspondance map: the keys are actually `(lo, hi)` of `span`s. We don't
+/// need the `span` context later on, only their position, so instead of keep a whole `Span`, we
+/// only keep the `lo` and `hi`.
+pub(crate) fn collect_spans_and_sources(
+    tcx: TyCtxt<'_>,
+    krate: &clean::Crate,
+    src_root: &Path,
+    include_sources: bool,
+    generate_link_to_definition: bool,
+) -> (FxHashMap<PathBuf, String>, FxHashMap<Span, LinkFromSrc>) {
+    let mut visitor = SpanMapVisitor { tcx, matches: FxHashMap::default() };
+
+    if include_sources {
+        if generate_link_to_definition {
+            tcx.hir().walk_toplevel_module(&mut visitor);
+        }
+        let sources = sources::collect_local_sources(tcx, src_root, krate);
+        (sources, visitor.matches)
+    } else {
+        (Default::default(), Default::default())
+    }
+}
+
+struct SpanMapVisitor<'tcx> {
+    pub(crate) tcx: TyCtxt<'tcx>,
+    pub(crate) matches: FxHashMap<Span, LinkFromSrc>,
+}
+
+impl<'tcx> SpanMapVisitor<'tcx> {
+    /// This function is where we handle `hir::Path` elements and add them into the "span map".
+    fn handle_path(&mut self, path: &rustc_hir::Path<'_>) {
+        let info = match path.res {
+            // FIXME: For now, we handle `DefKind` if it's not a `DefKind::TyParam`.
+            // Would be nice to support them too alongside the other `DefKind`
+            // (such as primitive types!).
+            Res::Def(kind, def_id) if kind != DefKind::TyParam => Some(def_id),
+            Res::Local(_) => None,
+            Res::PrimTy(p) => {
+                // FIXME: Doesn't handle "path-like" primitives like arrays or tuples.
+                self.matches.insert(path.span, LinkFromSrc::Primitive(PrimitiveType::from(p)));
+                return;
+            }
+            Res::Err => return,
+            _ => return,
+        };
+        if let Some(span) = self.tcx.hir().res_span(path.res) {
+            self.matches.insert(path.span, LinkFromSrc::Local(clean::Span::new(span)));
+        } else if let Some(def_id) = info {
+            self.matches.insert(path.span, LinkFromSrc::External(def_id));
+        }
+    }
+
+    /// Adds the macro call into the span map. Returns `true` if the `span` was inside a macro
+    /// expansion, whether or not it was added to the span map.
+    ///
+    /// The idea for the macro support is to check if the current `Span` comes from expansion. If
+    /// so, we loop until we find the macro definition by using `outer_expn_data` in a loop.
+    /// Finally, we get the information about the macro itself (`span` if "local", `DefId`
+    /// otherwise) and store it inside the span map.
+    fn handle_macro(&mut self, span: Span) -> bool {
+        if !span.from_expansion() {
+            return false;
+        }
+        // So if the `span` comes from a macro expansion, we need to get the original
+        // macro's `DefId`.
+        let mut data = span.ctxt().outer_expn_data();
+        let mut call_site = data.call_site;
+        // Macros can expand to code containing macros, which will in turn be expanded, etc.
+        // So the idea here is to "go up" until we're back to code that was generated from
+        // macro expansion so that we can get the `DefId` of the original macro that was at the
+        // origin of this expansion.
+        while call_site.from_expansion() {
+            data = call_site.ctxt().outer_expn_data();
+            call_site = data.call_site;
+        }
+
+        let macro_name = match data.kind {
+            ExpnKind::Macro(MacroKind::Bang, macro_name) => macro_name,
+            // Even though we don't handle this kind of macro, this `data` still comes from
+            // expansion so we return `true` so we don't go any deeper in this code.
+            _ => return true,
+        };
+        let link_from_src = match data.macro_def_id {
+            Some(macro_def_id) if macro_def_id.is_local() => {
+                LinkFromSrc::Local(clean::Span::new(data.def_site))
+            }
+            Some(macro_def_id) => LinkFromSrc::External(macro_def_id),
+            None => return true,
+        };
+        let new_span = data.call_site;
+        let macro_name = macro_name.as_str();
+        // The "call_site" includes the whole macro with its "arguments". We only want
+        // the macro name.
+        let new_span = new_span.with_hi(new_span.lo() + BytePos(macro_name.len() as u32));
+        self.matches.insert(new_span, link_from_src);
+        true
+    }
+}
+
+impl<'tcx> Visitor<'tcx> for SpanMapVisitor<'tcx> {
+    type NestedFilter = nested_filter::All;
+
+    fn nested_visit_map(&mut self) -> Self::Map {
+        self.tcx.hir()
+    }
+
+    fn visit_path(&mut self, path: &'tcx rustc_hir::Path<'tcx>, _id: HirId) {
+        if self.handle_macro(path.span) {
+            return;
+        }
+        self.handle_path(path);
+        intravisit::walk_path(self, path);
+    }
+
+    fn visit_mod(&mut self, m: &'tcx Mod<'tcx>, span: Span, id: HirId) {
+        // To make the difference between "mod foo {}" and "mod foo;". In case we "import" another
+        // file, we want to link to it. Otherwise no need to create a link.
+        if !span.overlaps(m.spans.inner_span) {
+            // Now that we confirmed it's a file import, we want to get the span for the module
+            // name only and not all the "mod foo;".
+            if let Some(Node::Item(item)) = self.tcx.hir().find(id) {
+                self.matches.insert(
+                    item.ident.span,
+                    LinkFromSrc::Local(clean::Span::new(m.spans.inner_span)),
+                );
+            }
+        }
+        intravisit::walk_mod(self, m, id);
+    }
+
+    fn visit_expr(&mut self, expr: &'tcx rustc_hir::Expr<'tcx>) {
+        if let ExprKind::MethodCall(segment, ..) = expr.kind {
+            if let Some(hir_id) = segment.hir_id {
+                let hir = self.tcx.hir();
+                let body_id = hir.enclosing_body_owner(hir_id);
+                // FIXME: this is showing error messages for parts of the code that are not
+                // compiled (because of cfg)!
+                //
+                // See discussion in https://github.com/rust-lang/rust/issues/69426#issuecomment-1019412352
+                let typeck_results = self.tcx.typeck_body(
+                    hir.maybe_body_owned_by(body_id).expect("a body which isn't a body"),
+                );
+                if let Some(def_id) = typeck_results.type_dependent_def_id(expr.hir_id) {
+                    self.matches.insert(
+                        segment.ident.span,
+                        match hir.span_if_local(def_id) {
+                            Some(span) => LinkFromSrc::Local(clean::Span::new(span)),
+                            None => LinkFromSrc::External(def_id),
+                        },
+                    );
+                }
+            }
+        } else if self.handle_macro(expr.span) {
+            // We don't want to go deeper into the macro.
+            return;
+        }
+        intravisit::walk_expr(self, expr);
+    }
+
+    fn visit_use(&mut self, path: &'tcx rustc_hir::Path<'tcx>, id: HirId) {
+        if self.handle_macro(path.span) {
+            return;
+        }
+        self.handle_path(path);
+        intravisit::walk_use(self, path, id);
+    }
+}
diff --git a/src/librustdoc/html/render/tests.rs b/src/librustdoc/html/render/tests.rs
new file mode 100644
index 000000000..3175fbe56
--- /dev/null
+++ b/src/librustdoc/html/render/tests.rs
@@ -0,0 +1,54 @@
+use std::cmp::Ordering;
+
+use super::print_item::compare_names;
+use super::{AllTypes, Buffer};
+
+#[test]
+fn test_compare_names() {
+    for &(a, b) in &[
+        ("hello", "world"),
+        ("", "world"),
+        ("123", "hello"),
+        ("123", ""),
+        ("123test", "123"),
+        ("hello", ""),
+        ("hello", "hello"),
+        ("hello123", "hello123"),
+        ("hello123", "hello12"),
+        ("hello12", "hello123"),
+        ("hello01abc", "hello01xyz"),
+        ("hello0abc", "hello0"),
+        ("hello0", "hello0abc"),
+        ("01", "1"),
+    ] {
+        assert_eq!(compare_names(a, b), a.cmp(b), "{:?} - {:?}", a, b);
+    }
+    assert_eq!(compare_names("u8", "u16"), Ordering::Less);
+    assert_eq!(compare_names("u32", "u16"), Ordering::Greater);
+    assert_eq!(compare_names("u8_to_f64", "u16_to_f64"), Ordering::Less);
+    assert_eq!(compare_names("u32_to_f64", "u16_to_f64"), Ordering::Greater);
+    assert_eq!(compare_names("u16_to_f64", "u16_to_f64"), Ordering::Equal);
+    assert_eq!(compare_names("u16_to_f32", "u16_to_f64"), Ordering::Less);
+}
+
+#[test]
+fn test_name_sorting() {
+    let names = [
+        "Apple", "Banana", "Fruit", "Fruit0", "Fruit00", "Fruit01", "Fruit1", "Fruit02", "Fruit2",
+        "Fruit20", "Fruit30x", "Fruit100", "Pear",
+    ];
+    let mut sorted = names.to_owned();
+    sorted.sort_by(|&l, r| compare_names(l, r));
+    assert_eq!(names, sorted);
+}
+
+#[test]
+fn test_all_types_prints_header_once() {
+    // Regression test for #82477
+    let all_types = AllTypes::new();
+
+    let mut buffer = Buffer::new();
+    all_types.print(&mut buffer);
+
+    assert_eq!(1, buffer.into_inner().matches("List of all items").count());
+}
diff --git a/src/librustdoc/html/render/write_shared.rs b/src/librustdoc/html/render/write_shared.rs
new file mode 100644
index 000000000..6fb41ff32
--- /dev/null
+++ b/src/librustdoc/html/render/write_shared.rs
@@ -0,0 +1,600 @@
+use std::ffi::OsStr;
+use std::fmt::Write;
+use std::fs::{self, File};
+use std::io::prelude::*;
+use std::io::{self, BufReader};
+use std::path::{Component, Path, PathBuf};
+use std::rc::Rc;
+use std::sync::LazyLock as Lazy;
+
+use itertools::Itertools;
+use rustc_data_structures::flock;
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use serde::Serialize;
+
+use super::{collect_paths_for_type, ensure_trailing_slash, Context, BASIC_KEYWORDS};
+use crate::clean::Crate;
+use crate::config::{EmitType, RenderOptions};
+use crate::docfs::PathError;
+use crate::error::Error;
+use crate::html::{layout, static_files};
+use crate::{try_err, try_none};
+
+static FILES_UNVERSIONED: Lazy<FxHashMap<&str, &[u8]>> = Lazy::new(|| {
+    map! {
+        "FiraSans-Regular.woff2" => static_files::fira_sans::REGULAR,
+        "FiraSans-Medium.woff2" => static_files::fira_sans::MEDIUM,
+        "FiraSans-LICENSE.txt" => static_files::fira_sans::LICENSE,
+        "SourceSerif4-Regular.ttf.woff2" => static_files::source_serif_4::REGULAR,
+        "SourceSerif4-Bold.ttf.woff2" => static_files::source_serif_4::BOLD,
+        "SourceSerif4-It.ttf.woff2" => static_files::source_serif_4::ITALIC,
+        "SourceSerif4-LICENSE.md" => static_files::source_serif_4::LICENSE,
+        "SourceCodePro-Regular.ttf.woff2" => static_files::source_code_pro::REGULAR,
+        "SourceCodePro-Semibold.ttf.woff2" => static_files::source_code_pro::SEMIBOLD,
+        "SourceCodePro-It.ttf.woff2" => static_files::source_code_pro::ITALIC,
+        "SourceCodePro-LICENSE.txt" => static_files::source_code_pro::LICENSE,
+        "NanumBarunGothic.ttf.woff2" => static_files::nanum_barun_gothic::REGULAR,
+        "NanumBarunGothic-LICENSE.txt" => static_files::nanum_barun_gothic::LICENSE,
+        "LICENSE-MIT.txt" => static_files::LICENSE_MIT,
+        "LICENSE-APACHE.txt" => static_files::LICENSE_APACHE,
+        "COPYRIGHT.txt" => static_files::COPYRIGHT,
+    }
+});
+
+enum SharedResource<'a> {
+    /// This file will never change, no matter what toolchain is used to build it.
+    ///
+    /// It does not have a resource suffix.
+    Unversioned { name: &'static str },
+    /// This file may change depending on the toolchain.
+    ///
+    /// It has a resource suffix.
+    ToolchainSpecific { basename: &'static str },
+    /// This file may change for any crate within a build, or based on the CLI arguments.
+    ///
+    /// This differs from normal invocation-specific files because it has a resource suffix.
+    InvocationSpecific { basename: &'a str },
+}
+
+impl SharedResource<'_> {
+    fn extension(&self) -> Option<&OsStr> {
+        use SharedResource::*;
+        match self {
+            Unversioned { name }
+            | ToolchainSpecific { basename: name }
+            | InvocationSpecific { basename: name } => Path::new(name).extension(),
+        }
+    }
+
+    fn path(&self, cx: &Context<'_>) -> PathBuf {
+        match self {
+            SharedResource::Unversioned { name } => cx.dst.join(name),
+            SharedResource::ToolchainSpecific { basename } => cx.suffix_path(basename),
+            SharedResource::InvocationSpecific { basename } => cx.suffix_path(basename),
+        }
+    }
+
+    fn should_emit(&self, emit: &[EmitType]) -> bool {
+        if emit.is_empty() {
+            return true;
+        }
+        let kind = match self {
+            SharedResource::Unversioned { .. } => EmitType::Unversioned,
+            SharedResource::ToolchainSpecific { .. } => EmitType::Toolchain,
+            SharedResource::InvocationSpecific { .. } => EmitType::InvocationSpecific,
+        };
+        emit.contains(&kind)
+    }
+}
+
+impl Context<'_> {
+    fn suffix_path(&self, filename: &str) -> PathBuf {
+        // We use splitn vs Path::extension here because we might get a filename
+        // like `style.min.css` and we want to process that into
+        // `style-suffix.min.css`.  Path::extension would just return `css`
+        // which would result in `style.min-suffix.css` which isn't what we
+        // want.
+        let (base, ext) = filename.split_once('.').unwrap();
+        let filename = format!("{}{}.{}", base, self.shared.resource_suffix, ext);
+        self.dst.join(&filename)
+    }
+
+    fn write_shared(
+        &self,
+        resource: SharedResource<'_>,
+        contents: impl 'static + Send + AsRef<[u8]>,
+        emit: &[EmitType],
+    ) -> Result<(), Error> {
+        if resource.should_emit(emit) {
+            self.shared.fs.write(resource.path(self), contents)
+        } else {
+            Ok(())
+        }
+    }
+
+    fn write_minify(
+        &self,
+        resource: SharedResource<'_>,
+        contents: impl 'static + Send + AsRef<str> + AsRef<[u8]>,
+        minify: bool,
+        emit: &[EmitType],
+    ) -> Result<(), Error> {
+        if minify {
+            let contents = contents.as_ref();
+            let contents = if resource.extension() == Some(OsStr::new("css")) {
+                minifier::css::minify(contents)
+                    .map_err(|e| {
+                        Error::new(format!("failed to minify CSS file: {}", e), resource.path(self))
+                    })?
+                    .to_string()
+            } else {
+                minifier::js::minify(contents).to_string()
+            };
+            self.write_shared(resource, contents, emit)
+        } else {
+            self.write_shared(resource, contents, emit)
+        }
+    }
+}
+
+pub(super) fn write_shared(
+    cx: &mut Context<'_>,
+    krate: &Crate,
+    search_index: String,
+    options: &RenderOptions,
+) -> Result<(), Error> {
+    // Write out the shared files. Note that these are shared among all rustdoc
+    // docs placed in the output directory, so this needs to be a synchronized
+    // operation with respect to all other rustdocs running around.
+    let lock_file = cx.dst.join(".lock");
+    let _lock = try_err!(flock::Lock::new(&lock_file, true, true, true), &lock_file);
+
+    // Minified resources are usually toolchain resources. If they're not, they should use `cx.write_minify` directly.
+    fn write_minify(
+        basename: &'static str,
+        contents: impl 'static + Send + AsRef<str> + AsRef<[u8]>,
+        cx: &Context<'_>,
+        options: &RenderOptions,
+    ) -> Result<(), Error> {
+        cx.write_minify(
+            SharedResource::ToolchainSpecific { basename },
+            contents,
+            options.enable_minification,
+            &options.emit,
+        )
+    }
+
+    // Toolchain resources should never be dynamic.
+    let write_toolchain = |p: &'static _, c: &'static _| {
+        cx.write_shared(SharedResource::ToolchainSpecific { basename: p }, c, &options.emit)
+    };
+
+    // Crate resources should always be dynamic.
+    let write_crate = |p: &_, make_content: &dyn Fn() -> Result<Vec<u8>, Error>| {
+        let content = make_content()?;
+        cx.write_shared(SharedResource::InvocationSpecific { basename: p }, content, &options.emit)
+    };
+
+    // Given "foo.svg", return e.g. "url(\"foo1.58.0.svg\")"
+    fn ver_url(cx: &Context<'_>, basename: &'static str) -> String {
+        format!(
+            "url(\"{}\")",
+            SharedResource::ToolchainSpecific { basename }
+                .path(cx)
+                .file_name()
+                .unwrap()
+                .to_str()
+                .unwrap()
+        )
+    }
+
+    // We use the AUTOREPLACE mechanism to inject into our static JS and CSS certain
+    // values that are only known at doc build time. Since this mechanism is somewhat
+    // surprising when reading the code, please limit it to rustdoc.css.
+    write_minify(
+        "rustdoc.css",
+        static_files::RUSTDOC_CSS
+            .replace(
+                "/* AUTOREPLACE: */url(\"toggle-minus.svg\")",
+                &ver_url(cx, "toggle-minus.svg"),
+            )
+            .replace("/* AUTOREPLACE: */url(\"toggle-plus.svg\")", &ver_url(cx, "toggle-plus.svg"))
+            .replace("/* AUTOREPLACE: */url(\"down-arrow.svg\")", &ver_url(cx, "down-arrow.svg")),
+        cx,
+        options,
+    )?;
+
+    // Add all the static files. These may already exist, but we just
+    // overwrite them anyway to make sure that they're fresh and up-to-date.
+    write_minify("settings.css", static_files::SETTINGS_CSS, cx, options)?;
+    write_minify("noscript.css", static_files::NOSCRIPT_CSS, cx, options)?;
+
+    // To avoid "light.css" to be overwritten, we'll first run over the received themes and only
+    // then we'll run over the "official" styles.
+    let mut themes: FxHashSet<String> = FxHashSet::default();
+
+    for entry in &cx.shared.style_files {
+        let theme = entry.basename()?;
+        let extension =
+            try_none!(try_none!(entry.path.extension(), &entry.path).to_str(), &entry.path);
+
+        // Handle the official themes
+        match theme.as_str() {
+            "light" => write_minify("light.css", static_files::themes::LIGHT, cx, options)?,
+            "dark" => write_minify("dark.css", static_files::themes::DARK, cx, options)?,
+            "ayu" => write_minify("ayu.css", static_files::themes::AYU, cx, options)?,
+            _ => {
+                // Handle added third-party themes
+                let filename = format!("{}.{}", theme, extension);
+                write_crate(&filename, &|| Ok(try_err!(fs::read(&entry.path), &entry.path)))?;
+            }
+        };
+
+        themes.insert(theme.to_owned());
+    }
+
+    if (*cx.shared).layout.logo.is_empty() {
+        write_toolchain("rust-logo.svg", static_files::RUST_LOGO_SVG)?;
+    }
+    if (*cx.shared).layout.favicon.is_empty() {
+        write_toolchain("favicon.svg", static_files::RUST_FAVICON_SVG)?;
+        write_toolchain("favicon-16x16.png", static_files::RUST_FAVICON_PNG_16)?;
+        write_toolchain("favicon-32x32.png", static_files::RUST_FAVICON_PNG_32)?;
+    }
+    write_toolchain("wheel.svg", static_files::WHEEL_SVG)?;
+    write_toolchain("clipboard.svg", static_files::CLIPBOARD_SVG)?;
+    write_toolchain("down-arrow.svg", static_files::DOWN_ARROW_SVG)?;
+    write_toolchain("toggle-minus.svg", static_files::TOGGLE_MINUS_PNG)?;
+    write_toolchain("toggle-plus.svg", static_files::TOGGLE_PLUS_PNG)?;
+
+    let mut themes: Vec<&String> = themes.iter().collect();
+    themes.sort();
+
+    write_minify("main.js", static_files::MAIN_JS, cx, options)?;
+    write_minify("search.js", static_files::SEARCH_JS, cx, options)?;
+    write_minify("settings.js", static_files::SETTINGS_JS, cx, options)?;
+
+    if cx.include_sources {
+        write_minify("source-script.js", static_files::sidebar::SOURCE_SCRIPT, cx, options)?;
+    }
+
+    write_minify("storage.js", static_files::STORAGE_JS, cx, options)?;
+
+    if cx.shared.layout.scrape_examples_extension {
+        cx.write_minify(
+            SharedResource::InvocationSpecific { basename: "scrape-examples.js" },
+            static_files::SCRAPE_EXAMPLES_JS,
+            options.enable_minification,
+            &options.emit,
+        )?;
+    }
+
+    if let Some(ref css) = cx.shared.layout.css_file_extension {
+        let buffer = try_err!(fs::read_to_string(css), css);
+        // This varies based on the invocation, so it can't go through the write_minify wrapper.
+        cx.write_minify(
+            SharedResource::InvocationSpecific { basename: "theme.css" },
+            buffer,
+            options.enable_minification,
+            &options.emit,
+        )?;
+    }
+    write_minify("normalize.css", static_files::NORMALIZE_CSS, cx, options)?;
+    for (name, contents) in &*FILES_UNVERSIONED {
+        cx.write_shared(SharedResource::Unversioned { name }, contents, &options.emit)?;
+    }
+
+    fn collect(path: &Path, krate: &str, key: &str) -> io::Result<(Vec<String>, Vec<String>)> {
+        let mut ret = Vec::new();
+        let mut krates = Vec::new();
+
+        if path.exists() {
+            let prefix = format!(r#"{}["{}"]"#, key, krate);
+            for line in BufReader::new(File::open(path)?).lines() {
+                let line = line?;
+                if !line.starts_with(key) {
+                    continue;
+                }
+                if line.starts_with(&prefix) {
+                    continue;
+                }
+                ret.push(line.to_string());
+                krates.push(
+                    line[key.len() + 2..]
+                        .split('"')
+                        .next()
+                        .map(|s| s.to_owned())
+                        .unwrap_or_else(String::new),
+                );
+            }
+        }
+        Ok((ret, krates))
+    }
+
+    fn collect_json(path: &Path, krate: &str) -> io::Result<(Vec<String>, Vec<String>)> {
+        let mut ret = Vec::new();
+        let mut krates = Vec::new();
+
+        if path.exists() {
+            let prefix = format!("\"{}\"", krate);
+            for line in BufReader::new(File::open(path)?).lines() {
+                let line = line?;
+                if !line.starts_with('"') {
+                    continue;
+                }
+                if line.starts_with(&prefix) {
+                    continue;
+                }
+                if line.ends_with(",\\") {
+                    ret.push(line[..line.len() - 2].to_string());
+                } else {
+                    // Ends with "\\" (it's the case for the last added crate line)
+                    ret.push(line[..line.len() - 1].to_string());
+                }
+                krates.push(
+                    line.split('"')
+                        .find(|s| !s.is_empty())
+                        .map(|s| s.to_owned())
+                        .unwrap_or_else(String::new),
+                );
+            }
+        }
+        Ok((ret, krates))
+    }
+
+    use std::ffi::OsString;
+
+    #[derive(Debug)]
+    struct Hierarchy {
+        elem: OsString,
+        children: FxHashMap<OsString, Hierarchy>,
+        elems: FxHashSet<OsString>,
+    }
+
+    impl Hierarchy {
+        fn new(elem: OsString) -> Hierarchy {
+            Hierarchy { elem, children: FxHashMap::default(), elems: FxHashSet::default() }
+        }
+
+        fn to_json_string(&self) -> String {
+            let mut subs: Vec<&Hierarchy> = self.children.values().collect();
+            subs.sort_unstable_by(|a, b| a.elem.cmp(&b.elem));
+            let mut files = self
+                .elems
+                .iter()
+                .map(|s| format!("\"{}\"", s.to_str().expect("invalid osstring conversion")))
+                .collect::<Vec<_>>();
+            files.sort_unstable();
+            let subs = subs.iter().map(|s| s.to_json_string()).collect::<Vec<_>>().join(",");
+            let dirs = if subs.is_empty() && files.is_empty() {
+                String::new()
+            } else {
+                format!(",[{}]", subs)
+            };
+            let files = files.join(",");
+            let files = if files.is_empty() { String::new() } else { format!(",[{}]", files) };
+            format!(
+                "[\"{name}\"{dirs}{files}]",
+                name = self.elem.to_str().expect("invalid osstring conversion"),
+                dirs = dirs,
+                files = files
+            )
+        }
+    }
+
+    if cx.include_sources {
+        let mut hierarchy = Hierarchy::new(OsString::new());
+        for source in cx
+            .shared
+            .local_sources
+            .iter()
+            .filter_map(|p| p.0.strip_prefix(&cx.shared.src_root).ok())
+        {
+            let mut h = &mut hierarchy;
+            let mut elems = source
+                .components()
+                .filter_map(|s| match s {
+                    Component::Normal(s) => Some(s.to_owned()),
+                    _ => None,
+                })
+                .peekable();
+            loop {
+                let cur_elem = elems.next().expect("empty file path");
+                if elems.peek().is_none() {
+                    h.elems.insert(cur_elem);
+                    break;
+                } else {
+                    let e = cur_elem.clone();
+                    h = h.children.entry(cur_elem.clone()).or_insert_with(|| Hierarchy::new(e));
+                }
+            }
+        }
+
+        let dst = cx.dst.join(&format!("source-files{}.js", cx.shared.resource_suffix));
+        let make_sources = || {
+            let (mut all_sources, _krates) =
+                try_err!(collect_json(&dst, krate.name(cx.tcx()).as_str()), &dst);
+            all_sources.push(format!(
+                r#""{}":{}"#,
+                &krate.name(cx.tcx()),
+                hierarchy
+                    .to_json_string()
+                    // All these `replace` calls are because we have to go through JS string for JSON content.
+                    .replace('\\', r"\\")
+                    .replace('\'', r"\'")
+                    // We need to escape double quotes for the JSON.
+                    .replace("\\\"", "\\\\\"")
+            ));
+            all_sources.sort();
+            let mut v = String::from("var sourcesIndex = JSON.parse('{\\\n");
+            v.push_str(&all_sources.join(",\\\n"));
+            v.push_str("\\\n}');\ncreateSourceSidebar();\n");
+            Ok(v.into_bytes())
+        };
+        write_crate("source-files.js", &make_sources)?;
+    }
+
+    // Update the search index and crate list.
+    let dst = cx.dst.join(&format!("search-index{}.js", cx.shared.resource_suffix));
+    let (mut all_indexes, mut krates) =
+        try_err!(collect_json(&dst, krate.name(cx.tcx()).as_str()), &dst);
+    all_indexes.push(search_index);
+    krates.push(krate.name(cx.tcx()).to_string());
+    krates.sort();
+
+    // Sort the indexes by crate so the file will be generated identically even
+    // with rustdoc running in parallel.
+    all_indexes.sort();
+    write_crate("search-index.js", &|| {
+        let mut v = String::from("var searchIndex = JSON.parse('{\\\n");
+        v.push_str(&all_indexes.join(",\\\n"));
+        v.push_str(
+            r#"\
+}');
+if (typeof window !== 'undefined' && window.initSearch) {window.initSearch(searchIndex)};
+if (typeof exports !== 'undefined') {exports.searchIndex = searchIndex};
+"#,
+        );
+        Ok(v.into_bytes())
+    })?;
+
+    write_crate("crates.js", &|| {
+        let krates = krates.iter().map(|k| format!("\"{}\"", k)).join(",");
+        Ok(format!("window.ALL_CRATES = [{}];", krates).into_bytes())
+    })?;
+
+    if options.enable_index_page {
+        if let Some(index_page) = options.index_page.clone() {
+            let mut md_opts = options.clone();
+            md_opts.output = cx.dst.clone();
+            md_opts.external_html = (*cx.shared).layout.external_html.clone();
+
+            crate::markdown::render(&index_page, md_opts, cx.shared.edition())
+                .map_err(|e| Error::new(e, &index_page))?;
+        } else {
+            let shared = Rc::clone(&cx.shared);
+            let dst = cx.dst.join("index.html");
+            let page = layout::Page {
+                title: "Index of crates",
+                css_class: "mod",
+                root_path: "./",
+                static_root_path: shared.static_root_path.as_deref(),
+                description: "List of crates",
+                keywords: BASIC_KEYWORDS,
+                resource_suffix: &shared.resource_suffix,
+            };
+
+            let content = format!(
+                "<h1 class=\"fqn\">\
+                     <span class=\"in-band\">List of all crates</span>\
+                </h1><ul class=\"crate mod\">{}</ul>",
+                krates
+                    .iter()
+                    .map(|s| {
+                        format!(
+                            "<li><a class=\"crate mod\" href=\"{}index.html\">{}</a></li>",
+                            ensure_trailing_slash(s),
+                            s
+                        )
+                    })
+                    .collect::<String>()
+            );
+            let v = layout::render(&shared.layout, &page, "", content, &shared.style_files);
+            shared.fs.write(dst, v)?;
+        }
+    }
+
+    // Update the list of all implementors for traits
+    let dst = cx.dst.join("implementors");
+    let cache = cx.cache();
+    for (&did, imps) in &cache.implementors {
+        // Private modules can leak through to this phase of rustdoc, which
+        // could contain implementations for otherwise private types. In some
+        // rare cases we could find an implementation for an item which wasn't
+        // indexed, so we just skip this step in that case.
+        //
+        // FIXME: this is a vague explanation for why this can't be a `get`, in
+        //        theory it should be...
+        let (remote_path, remote_item_type) = match cache.exact_paths.get(&did) {
+            Some(p) => match cache.paths.get(&did).or_else(|| cache.external_paths.get(&did)) {
+                Some((_, t)) => (p, t),
+                None => continue,
+            },
+            None => match cache.external_paths.get(&did) {
+                Some((p, t)) => (p, t),
+                None => continue,
+            },
+        };
+
+        #[derive(Serialize)]
+        struct Implementor {
+            text: String,
+            synthetic: bool,
+            types: Vec<String>,
+        }
+
+        let implementors = imps
+            .iter()
+            .filter_map(|imp| {
+                // If the trait and implementation are in the same crate, then
+                // there's no need to emit information about it (there's inlining
+                // going on). If they're in different crates then the crate defining
+                // the trait will be interested in our implementation.
+                //
+                // If the implementation is from another crate then that crate
+                // should add it.
+                if imp.impl_item.item_id.krate() == did.krate || !imp.impl_item.item_id.is_local() {
+                    None
+                } else {
+                    Some(Implementor {
+                        text: imp.inner_impl().print(false, cx).to_string(),
+                        synthetic: imp.inner_impl().kind.is_auto(),
+                        types: collect_paths_for_type(imp.inner_impl().for_.clone(), cache),
+                    })
+                }
+            })
+            .collect::<Vec<_>>();
+
+        // Only create a js file if we have impls to add to it. If the trait is
+        // documented locally though we always create the file to avoid dead
+        // links.
+        if implementors.is_empty() && !cache.paths.contains_key(&did) {
+            continue;
+        }
+
+        let implementors = format!(
+            r#"implementors["{}"] = {};"#,
+            krate.name(cx.tcx()),
+            serde_json::to_string(&implementors).unwrap()
+        );
+
+        let mut mydst = dst.clone();
+        for part in &remote_path[..remote_path.len() - 1] {
+            mydst.push(part.to_string());
+        }
+        cx.shared.ensure_dir(&mydst)?;
+        mydst.push(&format!("{}.{}.js", remote_item_type, remote_path[remote_path.len() - 1]));
+
+        let (mut all_implementors, _) =
+            try_err!(collect(&mydst, krate.name(cx.tcx()).as_str(), "implementors"), &mydst);
+        all_implementors.push(implementors);
+        // Sort the implementors by crate so the file will be generated
+        // identically even with rustdoc running in parallel.
+        all_implementors.sort();
+
+        let mut v = String::from("(function() {var implementors = {};\n");
+        for implementor in &all_implementors {
+            writeln!(v, "{}", *implementor).unwrap();
+        }
+        v.push_str(
+            "if (window.register_implementors) {\
+                 window.register_implementors(implementors);\
+             } else {\
+                 window.pending_implementors = implementors;\
+             }",
+        );
+        v.push_str("})()");
+        cx.shared.fs.write(mydst, v)?;
+    }
+    Ok(())
+}
diff --git a/src/librustdoc/html/sources.rs b/src/librustdoc/html/sources.rs
new file mode 100644
index 000000000..d0fd637ba
--- /dev/null
+++ b/src/librustdoc/html/sources.rs
@@ -0,0 +1,303 @@
+use crate::clean;
+use crate::docfs::PathError;
+use crate::error::Error;
+use crate::html::format::Buffer;
+use crate::html::highlight;
+use crate::html::layout;
+use crate::html::render::{Context, BASIC_KEYWORDS};
+use crate::visit::DocVisitor;
+
+use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_hir::def_id::LOCAL_CRATE;
+use rustc_middle::ty::TyCtxt;
+use rustc_session::Session;
+use rustc_span::edition::Edition;
+use rustc_span::source_map::FileName;
+
+use std::ffi::OsStr;
+use std::fs;
+use std::path::{Component, Path, PathBuf};
+use std::rc::Rc;
+
+pub(crate) fn render(cx: &mut Context<'_>, krate: &clean::Crate) -> Result<(), Error> {
+    info!("emitting source files");
+
+    let dst = cx.dst.join("src").join(krate.name(cx.tcx()).as_str());
+    cx.shared.ensure_dir(&dst)?;
+
+    let mut collector = SourceCollector { dst, cx, emitted_local_sources: FxHashSet::default() };
+    collector.visit_crate(krate);
+    Ok(())
+}
+
+pub(crate) fn collect_local_sources<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    src_root: &Path,
+    krate: &clean::Crate,
+) -> FxHashMap<PathBuf, String> {
+    let mut lsc = LocalSourcesCollector { tcx, local_sources: FxHashMap::default(), src_root };
+    lsc.visit_crate(krate);
+    lsc.local_sources
+}
+
+struct LocalSourcesCollector<'a, 'tcx> {
+    tcx: TyCtxt<'tcx>,
+    local_sources: FxHashMap<PathBuf, String>,
+    src_root: &'a Path,
+}
+
+fn is_real_and_local(span: clean::Span, sess: &Session) -> bool {
+    span.cnum(sess) == LOCAL_CRATE && span.filename(sess).is_real()
+}
+
+impl LocalSourcesCollector<'_, '_> {
+    fn add_local_source(&mut self, item: &clean::Item) {
+        let sess = self.tcx.sess;
+        let span = item.span(self.tcx);
+        // skip all synthetic "files"
+        if !is_real_and_local(span, sess) {
+            return;
+        }
+        let filename = span.filename(sess);
+        let p = if let FileName::Real(file) = filename {
+            match file.into_local_path() {
+                Some(p) => p,
+                None => return,
+            }
+        } else {
+            return;
+        };
+        if self.local_sources.contains_key(&*p) {
+            // We've already emitted this source
+            return;
+        }
+
+        let mut href = String::new();
+        clean_path(self.src_root, &p, false, |component| {
+            href.push_str(&component.to_string_lossy());
+            href.push('/');
+        });
+
+        let mut src_fname = p.file_name().expect("source has no filename").to_os_string();
+        src_fname.push(".html");
+        href.push_str(&src_fname.to_string_lossy());
+        self.local_sources.insert(p, href);
+    }
+}
+
+impl DocVisitor for LocalSourcesCollector<'_, '_> {
+    fn visit_item(&mut self, item: &clean::Item) {
+        self.add_local_source(item);
+
+        self.visit_item_recur(item)
+    }
+}
+
+/// Helper struct to render all source code to HTML pages
+struct SourceCollector<'a, 'tcx> {
+    cx: &'a mut Context<'tcx>,
+
+    /// Root destination to place all HTML output into
+    dst: PathBuf,
+    emitted_local_sources: FxHashSet<PathBuf>,
+}
+
+impl DocVisitor for SourceCollector<'_, '_> {
+    fn visit_item(&mut self, item: &clean::Item) {
+        if !self.cx.include_sources {
+            return;
+        }
+
+        let tcx = self.cx.tcx();
+        let span = item.span(tcx);
+        let sess = tcx.sess;
+
+        // If we're not rendering sources, there's nothing to do.
+        // If we're including source files, and we haven't seen this file yet,
+        // then we need to render it out to the filesystem.
+        if is_real_and_local(span, sess) {
+            let filename = span.filename(sess);
+            let span = span.inner();
+            let pos = sess.source_map().lookup_source_file(span.lo());
+            let file_span = span.with_lo(pos.start_pos).with_hi(pos.end_pos);
+            // If it turns out that we couldn't read this file, then we probably
+            // can't read any of the files (generating html output from json or
+            // something like that), so just don't include sources for the
+            // entire crate. The other option is maintaining this mapping on a
+            // per-file basis, but that's probably not worth it...
+            self.cx.include_sources = match self.emit_source(&filename, file_span) {
+                Ok(()) => true,
+                Err(e) => {
+                    self.cx.shared.tcx.sess.span_err(
+                        span,
+                        &format!(
+                            "failed to render source code for `{}`: {}",
+                            filename.prefer_local(),
+                            e,
+                        ),
+                    );
+                    false
+                }
+            };
+        }
+
+        self.visit_item_recur(item)
+    }
+}
+
+impl SourceCollector<'_, '_> {
+    /// Renders the given filename into its corresponding HTML source file.
+    fn emit_source(
+        &mut self,
+        filename: &FileName,
+        file_span: rustc_span::Span,
+    ) -> Result<(), Error> {
+        let p = match *filename {
+            FileName::Real(ref file) => {
+                if let Some(local_path) = file.local_path() {
+                    local_path.to_path_buf()
+                } else {
+                    unreachable!("only the current crate should have sources emitted");
+                }
+            }
+            _ => return Ok(()),
+        };
+        if self.emitted_local_sources.contains(&*p) {
+            // We've already emitted this source
+            return Ok(());
+        }
+
+        let contents = match fs::read_to_string(&p) {
+            Ok(contents) => contents,
+            Err(e) => {
+                return Err(Error::new(e, &p));
+            }
+        };
+
+        // Remove the utf-8 BOM if any
+        let contents = contents.strip_prefix('\u{feff}').unwrap_or(&contents);
+
+        let shared = Rc::clone(&self.cx.shared);
+        // Create the intermediate directories
+        let mut cur = self.dst.clone();
+        let mut root_path = String::from("../../");
+        clean_path(&shared.src_root, &p, false, |component| {
+            cur.push(component);
+            root_path.push_str("../");
+        });
+
+        shared.ensure_dir(&cur)?;
+
+        let src_fname = p.file_name().expect("source has no filename").to_os_string();
+        let mut fname = src_fname.clone();
+        fname.push(".html");
+        cur.push(&fname);
+
+        let title = format!("{} - source", src_fname.to_string_lossy());
+        let desc = format!("Source of the Rust file `{}`.", filename.prefer_remapped());
+        let page = layout::Page {
+            title: &title,
+            css_class: "source",
+            root_path: &root_path,
+            static_root_path: shared.static_root_path.as_deref(),
+            description: &desc,
+            keywords: BASIC_KEYWORDS,
+            resource_suffix: &shared.resource_suffix,
+        };
+        let v = layout::render(
+            &shared.layout,
+            &page,
+            "",
+            |buf: &mut _| {
+                let cx = &mut self.cx;
+                print_src(
+                    buf,
+                    contents,
+                    cx.shared.edition(),
+                    file_span,
+                    cx,
+                    &root_path,
+                    None,
+                    SourceContext::Standalone,
+                )
+            },
+            &shared.style_files,
+        );
+        shared.fs.write(cur, v)?;
+        self.emitted_local_sources.insert(p);
+        Ok(())
+    }
+}
+
+/// Takes a path to a source file and cleans the path to it. This canonicalizes
+/// things like ".." to components which preserve the "top down" hierarchy of a
+/// static HTML tree. Each component in the cleaned path will be passed as an
+/// argument to `f`. The very last component of the path (ie the file name) will
+/// be passed to `f` if `keep_filename` is true, and ignored otherwise.
+pub(crate) fn clean_path<F>(src_root: &Path, p: &Path, keep_filename: bool, mut f: F)
+where
+    F: FnMut(&OsStr),
+{
+    // make it relative, if possible
+    let p = p.strip_prefix(src_root).unwrap_or(p);
+
+    let mut iter = p.components().peekable();
+
+    while let Some(c) = iter.next() {
+        if !keep_filename && iter.peek().is_none() {
+            break;
+        }
+
+        match c {
+            Component::ParentDir => f("up".as_ref()),
+            Component::Normal(c) => f(c),
+            _ => continue,
+        }
+    }
+}
+
+pub(crate) enum SourceContext {
+    Standalone,
+    Embedded { offset: usize },
+}
+
+/// Wrapper struct to render the source code of a file. This will do things like
+/// adding line numbers to the left-hand side.
+pub(crate) fn print_src(
+    buf: &mut Buffer,
+    s: &str,
+    edition: Edition,
+    file_span: rustc_span::Span,
+    context: &Context<'_>,
+    root_path: &str,
+    decoration_info: Option<highlight::DecorationInfo>,
+    source_context: SourceContext,
+) {
+    let lines = s.lines().count();
+    let mut line_numbers = Buffer::empty_from(buf);
+    line_numbers.write_str("<pre class=\"line-numbers\">");
+    match source_context {
+        SourceContext::Standalone => {
+            for line in 1..=lines {
+                writeln!(line_numbers, "<span id=\"{0}\">{0}</span>", line)
+            }
+        }
+        SourceContext::Embedded { offset } => {
+            for line in 1..=lines {
+                writeln!(line_numbers, "<span>{0}</span>", line + offset)
+            }
+        }
+    }
+    line_numbers.write_str("</pre>");
+    highlight::render_with_highlighting(
+        s,
+        buf,
+        None,
+        None,
+        None,
+        edition,
+        Some(line_numbers),
+        Some(highlight::HrefContext { context, file_span, root_path }),
+        decoration_info,
+    );
+}
diff --git a/src/librustdoc/html/static/.eslintrc.js b/src/librustdoc/html/static/.eslintrc.js
new file mode 100644
index 000000000..fcd925bb3
--- /dev/null
+++ b/src/librustdoc/html/static/.eslintrc.js
@@ -0,0 +1,96 @@
+module.exports = {
+    "env": {
+        "browser": true,
+        "es6": true
+    },
+    "extends": "eslint:recommended",
+    "parserOptions": {
+        "ecmaVersion": 2015,
+        "sourceType": "module"
+    },
+    "rules": {
+        "linebreak-style": [
+            "error",
+            "unix"
+        ],
+        "semi": [
+            "error",
+            "always"
+        ],
+        "quotes": [
+            "error",
+            "double"
+        ],
+        "linebreak-style": [
+            "error",
+            "unix"
+        ],
+        "no-trailing-spaces": "error",
+        "no-var": ["error"],
+        "prefer-const": ["error"],
+        "prefer-arrow-callback": ["error"],
+        "brace-style": [
+            "error",
+            "1tbs",
+            { "allowSingleLine": false }
+        ],
+        "keyword-spacing": [
+            "error",
+            { "before": true, "after": true }
+        ],
+        "arrow-spacing": [
+            "error",
+            { "before": true, "after": true }
+        ],
+        "key-spacing": [
+            "error",
+            { "beforeColon": false, "afterColon": true, "mode": "strict" }
+        ],
+        "func-call-spacing": ["error", "never"],
+        "space-infix-ops": "error",
+        "space-before-function-paren": ["error", "never"],
+        "space-before-blocks": "error",
+        "comma-dangle": ["error", "always-multiline"],
+        "comma-style": ["error", "last"],
+        "max-len": ["error", { "code": 100, "tabWidth": 4 }],
+        "eol-last": ["error", "always"],
+        "arrow-parens": ["error", "as-needed"],
+        "no-unused-vars": [
+            "error",
+            {
+                "argsIgnorePattern": "^_",
+                "varsIgnorePattern": "^_"
+            }
+        ],
+        "eqeqeq": "error",
+        "no-const-assign": "error",
+        "no-debugger": "error",
+        "no-dupe-args": "error",
+        "no-dupe-else-if": "error",
+        "no-dupe-keys": "error",
+        "no-duplicate-case": "error",
+        "no-ex-assign": "error",
+        "no-fallthrough": "error",
+        "no-invalid-regexp": "error",
+        "no-import-assign": "error",
+        "no-self-compare": "error",
+        "no-template-curly-in-string": "error",
+        "block-scoped-var": "error",
+        "guard-for-in": "error",
+        "no-alert": "error",
+        "no-confusing-arrow": "error",
+        "no-div-regex": "error",
+        "no-floating-decimal": "error",
+        "no-implicit-globals": "error",
+        "no-implied-eval": "error",
+        "no-label-var": "error",
+        "no-lonely-if": "error",
+        "no-mixed-operators": "error",
+        "no-multi-assign": "error",
+        "no-return-assign": "error",
+        "no-script-url": "error",
+        "no-sequences": "error",
+        "no-throw-literal": "error",
+        "no-div-regex": "error",
+    }
+};
diff --git a/src/librustdoc/html/static/COPYRIGHT.txt b/src/librustdoc/html/static/COPYRIGHT.txt
new file mode 100644
index 000000000..34e48134c
--- /dev/null
+++ b/src/librustdoc/html/static/COPYRIGHT.txt
@@ -0,0 +1,46 @@
+These documentation pages include resources by third parties. This copyright
+file applies only to those resources. The following third party resources are
+included, and carry their own copyright notices and license terms:
+
+* Fira Sans (FiraSans-Regular.woff2, FiraSans-Medium.woff2):
+
+    Copyright (c) 2014, Mozilla Foundation https://mozilla.org/
+    with Reserved Font Name Fira Sans.
+
+    Copyright (c) 2014, Telefonica S.A.
+
+    Licensed under the SIL Open Font License, Version 1.1.
+    See FiraSans-LICENSE.txt.
+
+* rustdoc.css, main.js, and playpen.js:
+
+    Copyright 2015 The Rust Developers.
+    Licensed under the Apache License, Version 2.0 (see LICENSE-APACHE.txt) or
+    the MIT license (LICENSE-MIT.txt) at your option.
+
+* normalize.css:
+
+    Copyright (c) Nicolas Gallagher and Jonathan Neal.
+    Licensed under the MIT license (see LICENSE-MIT.txt).
+
+* Source Code Pro (SourceCodePro-Regular.ttf.woff2,
+    SourceCodePro-Semibold.ttf.woff2, SourceCodePro-It.ttf.woff2):
+
+    Copyright 2010, 2012 Adobe Systems Incorporated (http://www.adobe.com/),
+    with Reserved Font Name 'Source'. All Rights Reserved. Source is a trademark
+    of Adobe Systems Incorporated in the United States and/or other countries.
+
+    Licensed under the SIL Open Font License, Version 1.1.
+    See SourceCodePro-LICENSE.txt.
+
+* Source Serif 4 (SourceSerif4-Regular.ttf.woff2, SourceSerif4-Bold.ttf.woff2,
+    SourceSerif4-It.ttf.woff2):
+
+    Copyright 2014-2021 Adobe (http://www.adobe.com/), with Reserved Font Name
+    'Source'. All Rights Reserved. Source is a trademark of Adobe in the United
+    States and/or other countries.
+
+    Licensed under the SIL Open Font License, Version 1.1.
+    See SourceSerif4-LICENSE.md.
+
+This copyright file is intended to be distributed with rustdoc output.
diff --git a/src/librustdoc/html/static/LICENSE-APACHE.txt b/src/librustdoc/html/static/LICENSE-APACHE.txt
new file mode 100644
index 000000000..16fe87b06
--- /dev/null
+++ b/src/librustdoc/html/static/LICENSE-APACHE.txt
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/src/librustdoc/html/static/LICENSE-MIT.txt b/src/librustdoc/html/static/LICENSE-MIT.txt
new file mode 100644
index 000000000..31aa79387
--- /dev/null
+++ b/src/librustdoc/html/static/LICENSE-MIT.txt
@@ -0,0 +1,23 @@
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/src/librustdoc/html/static/css/normalize.css b/src/librustdoc/html/static/css/normalize.css
new file mode 100644
index 000000000..fdb8a8c65
--- /dev/null
+++ b/src/librustdoc/html/static/css/normalize.css
@@ -0,0 +1,2 @@
+/* ignore-tidy-linelength */
+/*! normalize.css v8.0.1 | MIT License | github.com/necolas/normalize.css */ html{line-height:1.15;-webkit-text-size-adjust:100%}body{margin:0}main{display:block}h1{font-size:2em;margin:0.67em 0}hr{box-sizing:content-box;height:0;overflow:visible}pre{font-family:monospace, monospace;font-size:1em}a{background-color:transparent}abbr[title]{border-bottom:none;text-decoration:underline;text-decoration:underline dotted}b,strong{font-weight:bolder}code,kbd,samp{font-family:monospace, monospace;font-size:1em}small{font-size:80%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sub{bottom:-0.25em}sup{top:-0.5em}img{border-style:none}button,input,optgroup,select,textarea{font-family:inherit;font-size:100%;line-height:1.15;margin:0}button,input{overflow:visible}button,select{text-transform:none}[type="button"],[type="reset"],[type="submit"],button{-webkit-appearance:button}[type="button"]::-moz-focus-inner,[type="reset"]::-moz-focus-inner,[type="submit"]::-moz-focus-inner,button::-moz-focus-inner{border-style:none;padding:0}[type="button"]:-moz-focusring,[type="reset"]:-moz-focusring,[type="submit"]:-moz-focusring,button:-moz-focusring{outline:1px dotted ButtonText}fieldset{padding:0.35em 0.75em 0.625em}legend{box-sizing:border-box;color:inherit;display:table;max-width:100%;padding:0;white-space:normal}progress{vertical-align:baseline}textarea{overflow:auto}[type="checkbox"],[type="radio"]{box-sizing:border-box;padding:0}[type="number"]::-webkit-inner-spin-button,[type="number"]::-webkit-outer-spin-button{height:auto}[type="search"]{-webkit-appearance:textfield;outline-offset:-2px}[type="search"]::-webkit-search-decoration{-webkit-appearance:none}::-webkit-file-upload-button{-webkit-appearance:button;font:inherit}details{display:block}summary{display:list-item}template{display:none}[hidden]{display:none}
diff --git a/src/librustdoc/html/static/css/noscript.css b/src/librustdoc/html/static/css/noscript.css
new file mode 100644
index 000000000..0a19a99ab
--- /dev/null
+++ b/src/librustdoc/html/static/css/noscript.css
@@ -0,0 +1,20 @@
+/*
+This whole CSS file is used only in case rustdoc is rendered with javascript disabled. Since a lot
+of content is hidden by default (depending on the settings too), we have to overwrite some of the
+rules.
+*/
+
+#main-content .attributes {
+	/* Since there is no toggle (the "[-]") when JS is disabled, no need for this margin either. */
+	margin-left: 0 !important;
+}
+
+#copy-path {
+	/* It requires JS to work so no need to display it in this case. */
+	display: none;
+}
+
+.sub {
+	/* The search bar and related controls don't work without JS */
+	display: none;
+}
diff --git a/src/librustdoc/html/static/css/rustdoc.css b/src/librustdoc/html/static/css/rustdoc.css
new file mode 100644
index 000000000..83fe14550
--- /dev/null
+++ b/src/librustdoc/html/static/css/rustdoc.css
@@ -0,0 +1,2335 @@
+/* See FiraSans-LICENSE.txt for the Fira Sans license. */
+@font-face {
+	font-family: 'Fira Sans';
+	font-style: normal;
+	font-weight: 400;
+	src: local('Fira Sans'),
+		url("FiraSans-Regular.woff2") format("woff2");
+	font-display: swap;
+}
+@font-face {
+	font-family: 'Fira Sans';
+	font-style: normal;
+	font-weight: 500;
+	src: local('Fira Sans Medium'),
+		url("FiraSans-Medium.woff2") format("woff2");
+	font-display: swap;
+}
+
+/* See SourceSerif4-LICENSE.md for the Source Serif 4 license. */
+@font-face {
+	font-family: 'Source Serif 4';
+	font-style: normal;
+	font-weight: 400;
+	src: local('Source Serif 4'),
+		url("SourceSerif4-Regular.ttf.woff2") format("woff2");
+	font-display: swap;
+}
+@font-face {
+	font-family: 'Source Serif 4';
+	font-style: italic;
+	font-weight: 400;
+	src: local('Source Serif 4 Italic'),
+		url("SourceSerif4-It.ttf.woff2") format("woff2");
+	font-display: swap;
+}
+@font-face {
+	font-family: 'Source Serif 4';
+	font-style: normal;
+	font-weight: 700;
+	src: local('Source Serif 4 Bold'),
+		url("SourceSerif4-Bold.ttf.woff2") format("woff2");
+	font-display: swap;
+}
+
+/* See SourceCodePro-LICENSE.txt for the Source Code Pro license. */
+@font-face {
+	font-family: 'Source Code Pro';
+	font-style: normal;
+	font-weight: 400;
+	/* Avoid using locally installed font because bad versions are in circulation:
+	 * see https://github.com/rust-lang/rust/issues/24355 */
+	src: url("SourceCodePro-Regular.ttf.woff2") format("woff2");
+	font-display: swap;
+}
+@font-face {
+	font-family: 'Source Code Pro';
+	font-style: italic;
+	font-weight: 400;
+	src: url("SourceCodePro-It.ttf.woff2") format("woff2");
+	font-display: swap;
+}
+@font-face {
+	font-family: 'Source Code Pro';
+	font-style: normal;
+	font-weight: 600;
+	src: url("SourceCodePro-Semibold.ttf.woff2") format("woff2");
+	font-display: swap;
+}
+
+/* Avoid using legacy CJK serif fonts in Windows like Batang. */
+@font-face {
+	font-family: 'NanumBarunGothic';
+	src: url("NanumBarunGothic.ttf.woff2") format("woff2");
+	font-display: swap;
+	unicode-range: U+AC00-D7AF, U+1100-11FF, U+3130-318F, U+A960-A97F, U+D7B0-D7FF;
+}
+
+* {
+	-webkit-box-sizing: border-box;
+	-moz-box-sizing: border-box;
+	box-sizing: border-box;
+}
+
+/* This part handles the "default" theme being used depending on the system one. */
+html {
+	content: "";
+}
+@media (prefers-color-scheme: light) {
+	html {
+		content: "light";
+	}
+}
+@media (prefers-color-scheme: dark) {
+	html {
+		content: "dark";
+	}
+}
+
+/* General structure and fonts */
+
+body {
+	/* Line spacing at least 1.5 per Web Content Accessibility Guidelines
+	   https://www.w3.org/WAI/WCAG21/Understanding/visual-presentation.html */
+	font: 1rem/1.5 "Source Serif 4", NanumBarunGothic, serif;
+	margin: 0;
+	position: relative;
+	/* We use overflow-wrap: break-word for Safari, which doesn't recognize
+	   `anywhere`: https://developer.mozilla.org/en-US/docs/Web/CSS/overflow-wrap */
+	overflow-wrap: break-word;
+	/* Then override it with `anywhere`, which is required to make non-Safari browsers break
+	   more aggressively when we want them to. */
+	overflow-wrap: anywhere;
+
+	-webkit-font-feature-settings: "kern", "liga";
+	-moz-font-feature-settings: "kern", "liga";
+	font-feature-settings: "kern", "liga";
+
+	background-color: var(--main-background-color);
+	color: var(--main-color);
+}
+
+h1 {
+	font-size: 1.5rem; /* 24px */
+}
+h2 {
+	font-size: 1.375rem; /* 22px */
+}
+h3 {
+	font-size: 1.25rem; /* 20px */
+}
+h1, h2, h3, h4, h5, h6 {
+	font-weight: 500;
+}
+h1, h2, h3, h4 {
+	margin: 20px 0 15px 0;
+	padding-bottom: 6px;
+}
+.docblock h3, .docblock h4, h5, h6 {
+	margin: 15px 0 5px 0;
+}
+h1.fqn {
+	margin: 0;
+	padding: 0;
+	border-bottom-color: var(--headings-border-bottom-color);
+}
+h2, h3, h4 {
+	border-bottom-color: var(--headings-border-bottom-color);
+}
+.main-heading {
+	display: flex;
+	flex-wrap: wrap;
+	justify-content: space-between;
+	padding-bottom: 6px;
+	margin-bottom: 15px;
+}
+.main-heading a:hover {
+	text-decoration: underline;
+}
+#toggle-all-docs {
+	text-decoration: none;
+}
+/* The only headings that get underlines are:
+	 Markdown-generated headings within the top-doc
+	 Rustdoc-generated h2 section headings (e.g. "Implementations", "Required Methods", etc)
+	Underlines elsewhere in the documentation break up visual flow and tend to invert
+	section hierarchies. */
+h2,
+.top-doc .docblock > h3,
+.top-doc .docblock > h4 {
+	border-bottom: 1px solid var(--headings-border-bottom-color);
+}
+h3.code-header {
+	font-size: 1.125rem; /* 18px */
+}
+h4.code-header {
+	font-size: 1rem;
+}
+.code-header {
+	font-weight: 600;
+	border-bottom-style: none;
+	margin: 0;
+	padding: 0;
+	margin-top: 0.6em;
+	margin-bottom: 0.4em;
+}
+.impl,
+.impl-items .method,
+.methods .method,
+.impl-items .type,
+.methods .type,
+.impl-items .associatedconstant,
+.methods .associatedconstant,
+.impl-items .associatedtype,
+.methods .associatedtype {
+	flex-basis: 100%;
+	font-weight: 600;
+	position: relative;
+}
+
+div.impl-items > div {
+	padding-left: 0;
+}
+
+h1, h2, h3, h4, h5, h6,
+.sidebar,
+.mobile-topbar,
+a.source,
+.search-input,
+.search-results .result-name,
+.content table td:first-child > a,
+.item-left > a,
+.out-of-band,
+span.since,
+#source-sidebar, #sidebar-toggle,
+details.rustdoc-toggle > summary::before,
+div.impl-items > div:not(.docblock):not(.item-info),
+.content ul.crate a.crate,
+a.srclink,
+#main-content > .since,
+#help-button > button,
+details.rustdoc-toggle.top-doc > summary,
+details.rustdoc-toggle.top-doc > summary::before,
+details.rustdoc-toggle.non-exhaustive > summary,
+details.rustdoc-toggle.non-exhaustive > summary::before,
+.scraped-example-title,
+.more-examples-toggle summary, .more-examples-toggle .hide-more,
+.example-links a,
+/* This selector is for the items listed in the "all items" page. */
+#main-content > ul.docblock > li > a {
+	font-family: "Fira Sans", Arial, NanumBarunGothic, sans-serif;
+}
+
+h1, h2, h3, h4,
+a#toggle-all-docs,
+a.anchor,
+.small-section-header a,
+#source-sidebar a,
+pre.rust a,
+.sidebar h2 a,
+.sidebar h3 a,
+.mobile-topbar h2 a,
+.in-band a,
+.search-results a,
+.module-item .stab,
+.import-item .stab,
+.result-name .primitive > i, .result-name .keyword > i,
+.content .method .where,
+.content .fn .where,
+.content .where.fmt-newline {
+	color: var(--main-color);
+}
+
+ol, ul {
+	padding-left: 24px;
+}
+ul ul, ol ul, ul ol, ol ol {
+	margin-bottom: .625em;
+}
+
+p {
+	/* Paragraph spacing at least 1.5 times line spacing per Web Content Accessibility Guidelines.
+	   Line-height is 1.5rem, so line spacing is .5rem; .75em is 1.5 times that.
+	   https://www.w3.org/WAI/WCAG21/Understanding/visual-presentation.html */
+	margin: 0 0 .75em 0;
+}
+
+summary {
+	outline: none;
+}
+
+/* Fix some style changes due to normalize.css 8 */
+
+td,
+th {
+	padding: 0;
+}
+
+table {
+	border-collapse: collapse;
+}
+
+button,
+input,
+optgroup,
+select,
+textarea {
+	color: inherit;
+	font: inherit;
+	margin: 0;
+}
+
+button {
+	/* Buttons on Safari have different default padding than other platforms. Make them the same. */
+	padding: 1px 6px;
+}
+
+/* end tweaks for normalize.css 8 */
+
+.rustdoc {
+	display: flex;
+	flex-direction: row;
+	flex-wrap: nowrap;
+}
+
+main {
+	position: relative;
+	flex-grow: 1;
+	padding: 10px 15px 40px 45px;
+	min-width: 0;
+}
+
+.source main {
+	padding: 15px;
+}
+
+.width-limiter {
+	max-width: 960px;
+	margin-right: auto;
+}
+
+.source .width-limiter {
+	max-width: unset;
+}
+
+details:not(.rustdoc-toggle) summary {
+	margin-bottom: .6em;
+}
+
+code, pre, a.test-arrow, .code-header {
+	font-family: "Source Code Pro", monospace;
+}
+.docblock code, .docblock-short code {
+	border-radius: 3px;
+	padding: 0 0.125em;
+}
+.docblock pre code, .docblock-short pre code {
+	padding: 0;
+}
+pre {
+	padding: 14px;
+}
+.docblock.item-decl {
+	margin-left: 0;
+}
+.item-decl pre {
+	overflow-x: auto;
+}
+
+.source .content pre {
+	padding: 20px;
+}
+
+img {
+	max-width: 100%;
+}
+
+li {
+	position: relative;
+}
+
+.source .content {
+	max-width: none;
+	overflow: visible;
+	margin-left: 0px;
+}
+
+nav.sub {
+	position: relative;
+	font-size: 1rem;
+}
+
+.sub-container {
+	display: flex;
+	flex-direction: row;
+	flex-wrap: nowrap;
+}
+
+.sub-logo-container {
+	display: none;
+	margin-right: 20px;
+}
+
+.source .sub-logo-container {
+	display: block;
+}
+
+.source .sub-logo-container > img {
+	height: 60px;
+	width: 60px;
+	object-fit: contain;
+}
+
+.sidebar, .mobile-topbar, .sidebar-menu-toggle {
+	background-color: var(--sidebar-background-color);
+}
+
+.sidebar {
+	font-size: 0.875rem;
+	width: 250px;
+	min-width: 200px;
+	overflow-y: scroll;
+	position: sticky;
+	height: 100vh;
+	top: 0;
+	left: 0;
+}
+
+.sidebar-elems,
+.sidebar > .location {
+	padding-left: 24px;
+}
+
+.sidebar .location {
+	overflow-wrap: anywhere;
+}
+
+.rustdoc.source .sidebar {
+	width: 50px;
+	min-width: 0px;
+	max-width: 300px;
+	flex-grow: 0;
+	flex-shrink: 0;
+	flex-basis: auto;
+	border-right: 1px solid;
+	overflow-x: hidden;
+	/* The sidebar is by default hidden  */
+	overflow-y: hidden;
+}
+
+.rustdoc.source .sidebar .sidebar-logo {
+	display: none;
+}
+
+.source .sidebar, #sidebar-toggle, #source-sidebar {
+	background-color: var(--sidebar-background-color);
+}
+
+#sidebar-toggle > button:hover, #sidebar-toggle > button:focus {
+	background-color: var(--sidebar-background-color-hover);
+}
+
+.source .sidebar > *:not(#sidebar-toggle) {
+	opacity: 0;
+	visibility: hidden;
+}
+
+.source-sidebar-expanded .source .sidebar {
+	overflow-y: auto;
+}
+
+.source-sidebar-expanded .source .sidebar > *:not(#sidebar-toggle) {
+	opacity: 1;
+	visibility: visible;
+}
+
+#all-types {
+	margin-top: 1em;
+}
+
+/* Improve the scrollbar display on firefox */
+* {
+	scrollbar-width: initial;
+	scrollbar-color: var(--scrollbar-color);
+}
+.sidebar {
+	scrollbar-width: thin;
+	scrollbar-color: var(--scrollbar-color);
+}
+
+/* Improve the scrollbar display on webkit-based browsers */
+::-webkit-scrollbar {
+	width: 12px;
+}
+.sidebar::-webkit-scrollbar {
+	width: 8px;
+}
+::-webkit-scrollbar-track {
+	-webkit-box-shadow: inset 0;
+	background-color: var(--scrollbar-track-background-color);
+}
+.sidebar::-webkit-scrollbar-track {
+	background-color: var(--scrollbar-track-background-color);
+}
+::-webkit-scrollbar-thumb, .sidebar::-webkit-scrollbar-thumb {
+	background-color: var(--scrollbar-thumb-background-color);
+}
+
+/* Everything else */
+
+.hidden {
+	display: none !important;
+}
+
+.sidebar .logo-container {
+	display: flex;
+	margin-top: 10px;
+	margin-bottom: 10px;
+	justify-content: center;
+}
+
+.version {
+	overflow-wrap: break-word;
+}
+
+.logo-container > img {
+	height: 100px;
+	width: 100px;
+}
+
+.location:empty {
+	border: none;
+}
+
+.location a:first-of-type {
+	font-weight: 500;
+}
+
+.block {
+	padding: 0;
+}
+.block ul, .block li {
+	padding: 0;
+	margin: 0;
+	list-style: none;
+}
+
+.block a,
+h2.location a {
+	display: block;
+	padding: 0.25rem;
+	margin-left: -0.25rem;
+
+	text-overflow: ellipsis;
+	overflow: hidden;
+}
+
+.sidebar h2 {
+	border-bottom: none;
+	font-weight: 500;
+	padding: 0;
+	margin: 0;
+	margin-top: 0.7rem;
+	margin-bottom: 0.7rem;
+}
+
+.sidebar h3 {
+	font-size: 1.125rem; /* 18px */
+	font-weight: 500;
+	padding: 0;
+	margin: 0;
+}
+
+.sidebar-elems .block {
+	margin-bottom: 2em;
+}
+
+.sidebar-elems .block li a {
+	white-space: nowrap;
+}
+
+.mobile-topbar {
+	display: none;
+}
+
+.source .content pre.rust {
+	white-space: pre;
+	overflow: auto;
+	padding-left: 0;
+}
+
+.rustdoc .example-wrap {
+	display: inline-flex;
+	margin-bottom: 10px;
+}
+
+.example-wrap {
+	position: relative;
+	width: 100%;
+}
+
+.example-wrap > pre.line-number {
+	overflow: initial;
+	border: 1px solid;
+	padding: 13px 8px;
+	text-align: right;
+	border-top-left-radius: 5px;
+	border-bottom-left-radius: 5px;
+}
+
+.example-wrap > pre.rust a:hover {
+	text-decoration: underline;
+}
+
+.line-numbers {
+	text-align: right;
+}
+.rustdoc:not(.source) .example-wrap > pre:not(.line-number) {
+	width: 100%;
+	overflow-x: auto;
+}
+
+.rustdoc:not(.source) .example-wrap > pre.line-numbers {
+	width: auto;
+	overflow-x: visible;
+}
+
+.rustdoc .example-wrap > pre {
+	margin: 0;
+}
+
+#search {
+	position: relative;
+}
+
+.search-loading {
+	text-align: center;
+}
+
+#results > table {
+	width: 100%;
+	table-layout: fixed;
+}
+
+.content > .example-wrap pre.line-numbers {
+	position: relative;
+	-webkit-user-select: none;
+	-moz-user-select: none;
+	-ms-user-select: none;
+	user-select: none;
+}
+.line-numbers span {
+	cursor: pointer;
+}
+
+.docblock-short {
+	overflow-wrap: break-word;
+	overflow-wrap: anywhere;
+}
+.docblock-short p {
+	display: inline;
+}
+
+.docblock-short p {
+	overflow: hidden;
+	text-overflow: ellipsis;
+	margin: 0;
+}
+/* Wrap non-pre code blocks (`text`) but not (```text```). */
+.docblock > :not(pre) > code,
+.docblock-short > :not(pre) > code {
+	white-space: pre-wrap;
+}
+
+.top-doc .docblock h2 { font-size: 1.375rem; }
+.top-doc .docblock h3 { font-size: 1.25rem; }
+.top-doc .docblock h4,
+.top-doc .docblock h5 {
+	font-size: 1.125rem;
+}
+.top-doc .docblock h6 {
+	font-size: 1rem;
+}
+
+.docblock h5 { font-size: 1rem; }
+.docblock h6 { font-size: 0.875rem; }
+.docblock h1, .docblock h2, .docblock h3, .docblock h4, .docblock h5, .docblock h6 {
+	border-bottom-color: var(--headings-border-bottom-color);
+}
+
+.docblock {
+	margin-left: 24px;
+	position: relative;
+}
+
+.docblock > :not(.information):not(.more-examples-toggle) {
+	max-width: 100%;
+	overflow-x: auto;
+}
+
+.content .out-of-band {
+	flex-grow: 0;
+	font-size: 1.125rem;
+	font-weight: normal;
+	float: right;
+}
+
+.method > .code-header, .trait-impl > .code-header {
+	max-width: calc(100% - 41px);
+	display: block;
+}
+
+.content .in-band {
+	flex-grow: 1;
+	margin: 0px;
+	padding: 0px;
+	overflow-wrap: break-word;
+	overflow-wrap: anywhere;
+}
+
+.in-band > code, .in-band > .code-header {
+	display: inline-block;
+}
+
+.docblock code, .docblock-short code,
+pre, .rustdoc.source .example-wrap {
+	background-color: var(--code-block-background-color);
+}
+
+#main-content {
+	position: relative;
+}
+#main-content > .since {
+	top: inherit;
+}
+
+.content table:not(.table-display) {
+	border-spacing: 0 5px;
+}
+.content td { vertical-align: top; }
+.content td:first-child { padding-right: 20px; }
+.content td p:first-child { margin-top: 0; }
+.content td h1, .content td h2 { margin-left: 0; font-size: 1.125rem; }
+.content tr:first-child td { border-top: 0; }
+
+.docblock table {
+	margin: .5em 0;
+	width: calc(100% - 2px);
+	overflow-x: auto;
+	display: block;
+}
+
+.docblock table td {
+	padding: .5em;
+	border: 1px dashed;
+}
+
+.docblock table th {
+	padding: .5em;
+	text-align: left;
+	border: 1px solid;
+}
+
+.fields + table {
+	margin-bottom: 1em;
+}
+
+.content .item-list {
+	list-style-type: none;
+	padding: 0;
+}
+
+.content .multi-column {
+	-moz-column-count: 5;
+	-moz-column-gap: 2.5em;
+	-webkit-column-count: 5;
+	-webkit-column-gap: 2.5em;
+	column-count: 5;
+	column-gap: 2.5em;
+}
+.content .multi-column li { width: 100%; display: inline-block; }
+
+.content > .methods > .method {
+	font-size: 1rem;
+	position: relative;
+}
+/* Shift "where ..." part of method or fn definition down a line */
+.content .method .where,
+.content .fn .where,
+.content .where.fmt-newline {
+	display: block;
+	font-size: 0.875rem;
+}
+
+.content .methods > div:not(.notable-traits):not(.method) {
+	margin-left: 40px;
+	margin-bottom: 15px;
+}
+
+.content .docblock > .impl-items {
+	margin-left: 20px;
+	margin-top: -34px;
+}
+.content .docblock >.impl-items .table-display {
+	margin: 0;
+}
+.content .docblock >.impl-items table td {
+	padding: 0;
+}
+.content .docblock > .impl-items .table-display, .impl-items table td {
+	border: none;
+}
+
+.item-info {
+	display: block;
+}
+
+.content .item-info code {
+	font-size: 0.875rem;
+}
+
+.content .item-info {
+	position: relative;
+	margin-left: 24px;
+}
+
+.sub-variant > div > .item-info {
+	margin-top: initial;
+}
+
+.content .impl-items .docblock, .content .impl-items .item-info {
+	margin-bottom: .6em;
+}
+
+.content .impl-items > .item-info {
+	margin-left: 40px;
+}
+
+.methods > .item-info, .content .impl-items > .item-info {
+	margin-top: -8px;
+}
+
+.impl-items {
+	flex-basis: 100%;
+}
+
+#main-content > .item-info {
+	margin-top: 0;
+	margin-left: 0;
+}
+
+nav.sub {
+	flex-grow: 1;
+	margin-bottom: 25px;
+}
+.source nav.sub {
+	margin-left: 32px;
+}
+nav.main {
+	padding: 20px 0;
+	text-align: center;
+}
+nav.main .current {
+	border-top: 1px solid;
+	border-bottom: 1px solid;
+}
+nav.main .separator {
+	border: 1px solid;
+	display: inline-block;
+	height: 23px;
+	margin: 0 20px;
+}
+nav.sum { text-align: right; }
+nav.sub form { display: inline; }
+
+a {
+	text-decoration: none;
+	background: transparent;
+}
+
+.small-section-header {
+	display: flex;
+	justify-content: space-between;
+	position: relative;
+}
+
+.small-section-header:hover > .anchor {
+	display: initial;
+}
+
+.in-band:hover > .anchor, .impl:hover > .anchor, .method.trait-impl:hover > .anchor,
+.type.trait-impl:hover > .anchor, .associatedconstant.trait-impl:hover > .anchor,
+.associatedtype.trait-impl:hover > .anchor {
+	display: inline-block;
+	position: absolute;
+}
+.anchor {
+	display: none;
+	position: absolute;
+	left: -0.5em;
+	background: none !important;
+}
+.anchor.field {
+	left: -5px;
+}
+.small-section-header > .anchor {
+	left: -15px;
+	padding-right: 8px;
+}
+h2.small-section-header > .anchor {
+	padding-right: 6px;
+}
+.anchor::before {
+	content: '§';
+}
+
+.docblock a:not(.srclink):not(.test-arrow):not(.scrape-help):hover,
+.docblock-short a:not(.srclink):not(.test-arrow):not(.scrape-help):hover, .item-info a {
+	text-decoration: underline;
+}
+
+.block a.current.crate { font-weight: 500; }
+
+/*  In most contexts we use `overflow-wrap: anywhere` to ensure that we can wrap
+	as much as needed on mobile (see
+	src/test/rustdoc-gui/type-declaration-overflow.goml for an example of why
+	this matters). The `anywhere` value means:
+
+	"Soft wrap opportunities introduced by the word break are considered when
+	 calculating min-content intrinsic sizes."
+
+	https://developer.mozilla.org/en-US/docs/Web/CSS/overflow-wrap#values
+
+	For table layouts, that becomes a problem: the browser tries to make each
+	column as narrow as possible, and `overflow-wrap: anywhere` means it can do
+	so by breaking words - even if some other column could be shrunk without
+	breaking words! This shows up, for instance, in the `Structs` / `Modules` /
+	`Functions` (etcetera) sections of a module page, and when a docblock
+	contains a table.
+
+	So, for table layouts, override the default with break-word, which does
+	_not_ affect min-content intrinsic sizes.
+*/
+table,
+.item-table {
+	overflow-wrap: break-word;
+}
+
+.item-table {
+	display: table;
+}
+.item-row {
+	display: table-row;
+}
+.item-left, .item-right {
+	display: table-cell;
+}
+.item-left {
+	padding-right: 1.25rem;
+}
+
+.search-container {
+	position: relative;
+	display: flex;
+	height: 34px;
+}
+.search-container > * {
+	height: 100%;
+}
+.search-results-title {
+	display: inline;
+}
+#search-settings {
+	font-size: 1.5rem;
+	font-weight: 500;
+	margin-bottom: 20px;
+}
+#crate-search {
+	min-width: 115px;
+	margin-top: 5px;
+	padding-left: 0.15em;
+	padding-right: 23px;
+	border: 1px solid;
+	border-radius: 4px;
+	outline: none;
+	cursor: pointer;
+	-moz-appearance: none;
+	-webkit-appearance: none;
+	/* Removes default arrow from firefox */
+	background-repeat: no-repeat;
+	background-color: transparent;
+	background-size: 20px;
+	background-position: calc(100% - 1px) 56%;
+	background-image: /* AUTOREPLACE: */url("down-arrow.svg");
+	max-width: 100%;
+	text-overflow: ellipsis;
+}
+.search-container {
+	margin-top: 4px;
+}
+.search-input {
+	/* Override Normalize.css: it has a rule that sets
+	   -webkit-appearance: textfield for search inputs. That
+	   causes rounded corners and no border on iOS Safari. */
+	-webkit-appearance: none;
+	/* Override Normalize.css: we have margins and do
+	 not want to overflow - the `moz` attribute is necessary
+	 until Firefox 29, too early to drop at this point */
+	-moz-box-sizing: border-box !important;
+	box-sizing: border-box !important;
+	outline: none;
+	border: 1px solid;
+	border-radius: 2px;
+	padding: 8px;
+	font-size: 1rem;
+	width: 100%;
+}
+
+.search-results {
+	display: none;
+	padding-bottom: 2em;
+}
+
+.search-results.active {
+	display: block;
+	/* prevent overhanging tabs from moving the first result */
+	clear: both;
+}
+
+.search-results .desc > span {
+	white-space: nowrap;
+	text-overflow: ellipsis;
+	overflow: hidden;
+	display: block;
+}
+
+.search-results > a {
+	display: block;
+	width: 100%;
+	/* A little margin ensures the browser's outlining of focused links has room to display. */
+	margin-left: 2px;
+	margin-right: 2px;
+	border-bottom: 1px solid #aaa3;
+}
+
+.search-results > a > div {
+	display: flex;
+	flex-flow: row wrap;
+}
+
+.search-results .result-name, .search-results div.desc, .search-results .result-description {
+	width: 50%;
+}
+.search-results .result-name {
+	padding-right: 1em;
+}
+
+.search-results .result-name > span {
+	display: inline-block;
+	margin: 0;
+	font-weight: normal;
+}
+
+.popover {
+	font-size: 1rem;
+	position: absolute;
+	right: 0;
+	z-index: 2;
+	display: block;
+	margin-top: 7px;
+	border-radius: 3px;
+	border: 1px solid;
+	font-size: 1rem;
+}
+
+/* This rule is to draw the little arrow connecting the settings menu to the gear icon. */
+.popover::before {
+	content: '';
+	position: absolute;
+	right: 11px;
+	border: solid;
+	border-width: 1px 1px 0 0;
+	display: inline-block;
+	padding: 4px;
+	transform: rotate(-45deg);
+	top: -5px;
+}
+
+.popover, .popover::before {
+	background-color: var(--main-background-color);
+	color: var(--main-color);
+}
+
+#help-button .popover {
+	max-width: 600px;
+}
+
+#help-button .popover::before {
+	right: 48px;
+}
+
+#help-button dt {
+	float: left;
+	clear: left;
+	display: block;
+	margin-right: 0.5rem;
+}
+#help-button span.top, #help-button span.bottom {
+	text-align: center;
+	display: block;
+	font-size: 1.125rem;
+}
+#help-button span.top {
+	text-align: center;
+	display: block;
+	margin: 10px 0;
+	border-bottom: 1px solid;
+	padding-bottom: 4px;
+	margin-bottom: 6px;
+}
+#help-button span.bottom {
+	clear: both;
+	border-top: 1px solid;
+}
+.side-by-side {
+	text-align: initial;
+}
+.side-by-side > div {
+	width: 50%;
+	float: left;
+	padding: 0 20px 20px 17px;
+}
+
+.item-info .stab {
+	width: fit-content;
+	/* This min-height is needed to unify the height of the stab elements because some of them
+	   have emojis.
+	*/
+	min-height: 36px;
+	display: flex;
+	align-items: center;
+	white-space: pre-wrap;
+}
+.stab {
+	padding: 3px;
+	margin-bottom: 5px;
+	font-size: 0.875rem;
+	font-weight: normal;
+}
+.stab p {
+	display: inline;
+	margin: 0;
+}
+
+.stab .emoji {
+	font-size: 1.25rem;
+}
+
+/* Black one-pixel outline around emoji shapes */
+.emoji {
+	text-shadow:
+		1px 0 0 black,
+		-1px 0 0 black,
+		0  1px 0 black,
+		0 -1px 0 black;
+}
+
+.module-item .stab,
+.import-item .stab {
+	border-radius: 3px;
+	display: inline-block;
+	font-size: 0.875rem;
+	line-height: 1.2;
+	margin-bottom: 0;
+	margin-left: 0.3125em;
+	padding: 2px;
+	vertical-align: text-bottom;
+}
+
+.module-item.unstable,
+.import-item.unstable {
+	opacity: 0.65;
+}
+
+.since {
+	font-weight: normal;
+	font-size: initial;
+}
+
+.rightside {
+	padding-left: 12px;
+	padding-right: 2px;
+	position: initial;
+}
+
+.impl-items .srclink, .impl .srclink, .methods .srclink {
+	/* Override header settings otherwise it's too bold */
+	font-weight: normal;
+	font-size: 1rem;
+}
+
+.rightside {
+	float: right;
+}
+
+.variants_table {
+	width: 100%;
+}
+
+.variants_table tbody tr td:first-child {
+	width: 1%; /* make the variant name as small as possible */
+}
+
+td.summary-column {
+	width: 100%;
+}
+
+.summary {
+	padding-right: 0px;
+}
+
+pre.rust .question-mark {
+	font-weight: bold;
+}
+
+a.test-arrow {
+	display: inline-block;
+	visibility: hidden;
+	position: absolute;
+	padding: 5px 10px 5px 10px;
+	border-radius: 5px;
+	font-size: 1.375rem;
+	top: 5px;
+	right: 5px;
+	z-index: 1;
+}
+.example-wrap:hover .test-arrow {
+	visibility: visible;
+}
+a.test-arrow:hover{
+	text-decoration: none;
+}
+
+.code-attribute {
+	font-weight: 300;
+}
+
+.item-spacer {
+	width: 100%;
+	height: 12px;
+}
+
+.out-of-band > span.since {
+	position: initial;
+	font-size: 1.25rem;
+}
+
+h3.variant {
+	font-weight: 600;
+	font-size: 1.125rem;
+	margin-bottom: 10px;
+	border-bottom: none;
+}
+
+.sub-variant h4 {
+	font-size: 1rem;
+	font-weight: 400;
+	border-bottom: none;
+	margin-top: 0;
+	margin-bottom: 0;
+}
+
+.sub-variant {
+	margin-left: 24px;
+	margin-bottom: 40px;
+}
+
+.sub-variant > .sub-variant-field {
+	margin-left: 24px;
+}
+
+.toggle-label {
+	display: inline-block;
+	margin-left: 4px;
+	margin-top: 3px;
+}
+
+:target > code, :target > .code-header {
+	opacity: 1;
+}
+
+:target {
+	padding-right: 3px;
+}
+
+.information {
+	position: absolute;
+	left: -25px;
+	margin-top: 7px;
+	z-index: 1;
+}
+
+.tooltip {
+	position: relative;
+	display: inline-block;
+	cursor: pointer;
+}
+
+.tooltip::after {
+	display: none;
+	text-align: center;
+	padding: 5px 3px 3px 3px;
+	border-radius: 6px;
+	margin-left: 5px;
+	font-size: 1rem;
+}
+
+.tooltip.ignore::after {
+	content: "This example is not tested";
+}
+.tooltip.compile_fail::after {
+	content: "This example deliberately fails to compile";
+}
+.tooltip.should_panic::after {
+	content: "This example panics";
+}
+.tooltip.edition::after {
+	content: "This code runs with edition " attr(data-edition);
+}
+
+.tooltip::before {
+	content: " ";
+	position: absolute;
+	top: 50%;
+	left: 16px;
+	margin-top: -5px;
+	border-width: 5px;
+	border-style: solid;
+	display: none;
+}
+
+.tooltip:hover::before, .tooltip:hover::after {
+	display: inline;
+}
+
+.tooltip.compile_fail, .tooltip.should_panic, .tooltip.ignore {
+	font-weight: bold;
+	font-size: 1.25rem;
+}
+
+.notable-traits-tooltip {
+	display: inline-block;
+	cursor: pointer;
+}
+
+.notable-traits:hover .notable-traits-tooltiptext,
+.notable-traits .notable-traits-tooltiptext.force-tooltip {
+	display: inline-block;
+}
+
+.notable-traits .notable-traits-tooltiptext {
+	display: none;
+	padding: 5px 3px 3px 3px;
+	border-radius: 6px;
+	margin-left: 5px;
+	z-index: 10;
+	font-size: 1rem;
+	cursor: default;
+	position: absolute;
+	border: 1px solid;
+}
+
+.notable-traits-tooltip::after {
+	/* The margin on the tooltip does not capture hover events,
+	   this extends the area of hover enough so that mouse hover is not
+	   lost when moving the mouse to the tooltip */
+	content: "\00a0\00a0\00a0";
+}
+
+.notable-traits .notable, .notable-traits .docblock {
+	margin: 0;
+}
+
+.notable-traits .notable {
+	margin: 0;
+	margin-bottom: 13px;
+	font-size: 1.1875rem;
+	font-weight: 600;
+	display: block;
+}
+
+.notable-traits .docblock code.content{
+	margin: 0;
+	padding: 0;
+	font-size: 1.25rem;
+}
+
+/* Example code has the "Run" button that needs to be positioned relative to the pre */
+pre.rust.rust-example-rendered {
+	position: relative;
+}
+
+pre.rust {
+	tab-size: 4;
+	-moz-tab-size: 4;
+}
+
+.search-failed {
+	text-align: center;
+	margin-top: 20px;
+	display: none;
+}
+
+.search-failed.active {
+	display: block;
+}
+
+.search-failed > ul {
+	text-align: left;
+	max-width: 570px;
+	margin-left: auto;
+	margin-right: auto;
+}
+
+#titles {
+	height: 35px;
+}
+
+#titles > button {
+	float: left;
+	width: 33.3%;
+	text-align: center;
+	font-size: 1.125rem;
+	cursor: pointer;
+	border: 0;
+	border-top: 2px solid;
+}
+
+#titles > button:first-child:last-child {
+	margin-right: 1px;
+	width: calc(100% - 1px);
+}
+
+#titles > button:not(:last-child) {
+	margin-right: 1px;
+	width: calc(33.3% - 1px);
+}
+
+#titles > button > div.count {
+	display: inline-block;
+	font-size: 1rem;
+}
+
+.notable-traits {
+	cursor: pointer;
+	z-index: 2;
+	margin-left: 5px;
+}
+
+#sidebar-toggle {
+	position: sticky;
+	top: 0;
+	left: 0;
+	font-weight: bold;
+	font-size: 1.25rem;
+	border-bottom: 1px solid;
+	display: flex;
+	height: 40px;
+	justify-content: center;
+	align-items: center;
+	z-index: 10;
+}
+#source-sidebar {
+	width: 100%;
+	z-index: 1;
+	overflow: auto;
+}
+#source-sidebar > .title {
+	font-size: 1.5rem;
+	text-align: center;
+	border-bottom: 1px solid;
+	margin-bottom: 6px;
+}
+#sidebar-toggle > button {
+	background: none;
+	color: inherit;
+	cursor: pointer;
+	text-align: center;
+	border: none;
+	outline: none;
+	position: absolute;
+	top: 0;
+	bottom: 0;
+	left: 0;
+	right: 0;
+	/* work around button layout strangeness: https://stackoverflow.com/q/7271561 */
+	width: 100%;
+	/* iOS button gradient: https://stackoverflow.com/q/5438567 */
+	-webkit-appearance: none;
+	opacity: 1;
+}
+#settings-menu, #help-button {
+	margin-left: 4px;
+	outline: none;
+}
+
+#copy-path {
+	height: 34px;
+}
+#settings-menu > a, #help-button > button, #copy-path {
+	padding: 5px;
+	width: 33px;
+	border: 1px solid;
+	border-radius: 2px;
+	cursor: pointer;
+}
+#settings-menu {
+	padding: 0;
+}
+#settings-menu > a, #help-button > button {
+	padding: 5px;
+	height: 100%;
+	display: block;
+}
+
+@keyframes rotating {
+	from {
+		transform: rotate(0deg);
+	}
+	to {
+		transform: rotate(360deg);
+	}
+}
+#settings-menu.rotate > a img {
+	animation: rotating 2s linear infinite;
+}
+
+.setting-line .radio-line input:checked {
+	box-shadow: inset 0 0 0 3px var(--main-background-color);
+	background-color: var(--settings-input-color);
+}
+.setting-line .radio-line input:focus {
+	box-shadow: 0 0 1px 1px var(--settings-input-color);
+}
+/* In here we combine both `:focus` and `:checked` properties. */
+.setting-line .radio-line input:checked:focus {
+	box-shadow: inset 0 0 0 3px var(--main-background-color),
+		0 0 2px 2px var(--settings-input-color);
+}
+.setting-line .radio-line input:hover {
+	border-color: var(--settings-input-color) !important;
+}
+input:checked + .slider {
+	background-color: var(--settings-input-color);
+}
+
+#help-button > button {
+	text-align: center;
+	/* Rare exception to specifying font sizes in rem. Since this is acting
+	   as an icon, it's okay to specify their sizes in pixels. */
+	font-size: 20px;
+	padding-top: 2px;
+}
+
+#copy-path {
+	background: initial;
+	margin-left: 10px;
+	padding: 0;
+	padding-left: 2px;
+	border: 0;
+}
+
+#theme-choices {
+	display: none;
+	position: absolute;
+	left: 0;
+	top: 28px;
+	border: 1px solid;
+	border-radius: 3px;
+	z-index: 1;
+	cursor: pointer;
+}
+
+#theme-choices > button {
+	border: none;
+	width: 100%;
+	padding: 4px 8px;
+	text-align: center;
+	background: rgba(0,0,0,0);
+	overflow-wrap: normal;
+}
+
+#theme-choices > button:not(:first-child) {
+	border-top: 1px solid;
+}
+
+kbd {
+	display: inline-block;
+	padding: 3px 5px;
+	font: 15px monospace;
+	line-height: 10px;
+	vertical-align: middle;
+	border: solid 1px;
+	border-radius: 3px;
+	cursor: default;
+}
+
+.hidden-by-impl-hider,
+.hidden-by-usual-hider {
+	/* important because of conflicting rule for small screens */
+	display: none !important;
+}
+
+#implementations-list > h3 > span.in-band {
+	width: 100%;
+}
+
+.table-display {
+	width: 100%;
+	border: 0;
+	border-collapse: collapse;
+	border-spacing: 0;
+	font-size: 1rem;
+}
+
+.table-display tr td:first-child {
+	padding-right: 0;
+}
+
+.table-display tr td:last-child {
+	float: right;
+}
+.table-display .out-of-band {
+	position: relative;
+	font-size: 1.125rem;
+	display: block;
+}
+
+.table-display td:hover .anchor {
+	display: block;
+	top: 2px;
+	left: -5px;
+}
+
+#main-content > ul {
+	padding-left: 10px;
+}
+#main-content > ul > li {
+	list-style: none;
+}
+
+.non-exhaustive {
+	margin-bottom: 1em;
+}
+
+details.dir-entry {
+	padding-left: 4px;
+}
+
+details.dir-entry > summary {
+	margin: 0 0 0 13px;
+	list-style-position: outside;
+	cursor: pointer;
+}
+
+details.dir-entry div.folders, details.dir-entry div.files {
+	padding-left: 23px;
+}
+
+details.dir-entry a {
+	display: block;
+}
+
+/* The hideme class is used on summary tags that contain a span with
+	placeholder text shown only when the toggle is closed. For instance,
+	"Expand description" or "Show methods". */
+details.rustdoc-toggle > summary.hideme {
+	cursor: pointer;
+}
+
+details.rustdoc-toggle > summary {
+	list-style: none;
+}
+details.rustdoc-toggle > summary::-webkit-details-marker,
+details.rustdoc-toggle > summary::marker {
+	display: none;
+}
+
+details.rustdoc-toggle > summary.hideme > span {
+	margin-left: 9px;
+}
+
+details.rustdoc-toggle > summary::before {
+	content: "";
+	cursor: pointer;
+	width: 16px;
+	height: 16px;
+	background-repeat: no-repeat;
+	background-position: top left;
+	display: inline-block;
+	vertical-align: middle;
+	opacity: .5;
+}
+
+/* Screen readers see the text version at the end the line.
+	Visual readers see the icon at the start of the line, but small and transparent. */
+details.rustdoc-toggle > summary::after {
+	content: "Expand";
+	overflow: hidden;
+	width: 0;
+	height: 0;
+	position: absolute;
+}
+
+details.rustdoc-toggle > summary.hideme::after {
+	/* "hideme" toggles already have a description when they're contracted */
+	content: "";
+}
+
+details.rustdoc-toggle > summary:focus::before,
+details.rustdoc-toggle > summary:hover::before {
+	opacity: 1;
+}
+
+details.rustdoc-toggle.top-doc > summary,
+details.rustdoc-toggle.top-doc > summary::before,
+details.rustdoc-toggle.non-exhaustive > summary,
+details.rustdoc-toggle.non-exhaustive > summary::before {
+	font-size: 1rem;
+}
+
+details.non-exhaustive {
+	margin-bottom: 8px;
+}
+
+details.rustdoc-toggle > summary.hideme::before {
+	position: relative;
+}
+
+details.rustdoc-toggle > summary:not(.hideme)::before {
+	position: absolute;
+	left: -24px;
+	top: 4px;
+}
+
+.impl-items > details.rustdoc-toggle > summary:not(.hideme)::before {
+	position: absolute;
+	left: -24px;
+}
+
+/* When a "hideme" summary is open and the "Expand description" or "Show
+	methods" text is hidden, we want the [-] toggle that remains to not
+	affect the layout of the items to its right. To do that, we use
+	absolute positioning. Note that we also set position: relative
+	on the parent <details> to make this work properly. */
+details.rustdoc-toggle[open] > summary.hideme {
+	position: absolute;
+}
+
+details.rustdoc-toggle {
+	position: relative;
+}
+
+details.rustdoc-toggle[open] > summary.hideme > span {
+	display: none;
+}
+
+details.rustdoc-toggle[open] > summary::before,
+details.rustdoc-toggle[open] > summary.hideme::before {
+	background-image: /* AUTOREPLACE: */url("toggle-minus.svg");
+}
+
+details.rustdoc-toggle > summary::before {
+	background-image: /* AUTOREPLACE: */url("toggle-plus.svg");
+}
+
+details.rustdoc-toggle[open] > summary::before,
+details.rustdoc-toggle[open] > summary.hideme::before {
+	width: 16px;
+	height: 16px;
+	background-repeat: no-repeat;
+	background-position: top left;
+	display: inline-block;
+	content: "";
+}
+
+details.rustdoc-toggle[open] > summary::after,
+details.rustdoc-toggle[open] > summary.hideme::after {
+	content: "Collapse";
+}
+
+/* This is needed in docblocks to have the "▶" element to be on the same line. */
+.docblock summary > * {
+	display: inline-block;
+}
+
+/* Media Queries */
+
+/*
+WARNING: RUSTDOC_MOBILE_BREAKPOINT MEDIA QUERY;
+If you update this line, then you also need to update the line with the same warning
+in storage.js plus the media query with (max-width: 700px)
+*/
+@media (min-width: 701px) {
+	/* In case there is no documentation before a code block, we need to add some margin at the top
+	to prevent an overlay between the "collapse toggle" and the information tooltip.
+	However, it's not needed with smaller screen width because the doc/code block is always put
+	"one line" below. */
+	.docblock > .information:first-child > .tooltip {
+		margin-top: 16px;
+	}
+
+	/* When we expand the sidebar on the source code page, we hide the logo on the left of the
+	search bar to have more space. */
+	.source-sidebar-expanded .source .sidebar + main .width-limiter .sub-logo-container.rust-logo {
+		display: none;
+	}
+
+	.source-sidebar-expanded .source .sidebar {
+		width: 300px;
+	}
+}
+
+/*
+WARNING: RUSTDOC_MOBILE_BREAKPOINT MEDIA QUERY
+If you update this line, then you also need to update the line with the same warning
+in storage.js plus the media query with (min-width: 701px)
+*/
+@media (max-width: 700px) {
+	/* When linking to an item with an `id` (for instance, by clicking a link in the sidebar,
+	   or visiting a URL with a fragment like `#method.new`, we don't want the item to be obscured
+	   by the topbar. Anything with an `id` gets scroll-margin-top equal to .mobile-topbar's size.
+	*/
+	*[id] {
+		scroll-margin-top: 45px;
+	}
+
+	.rustdoc {
+		padding-top: 0px;
+		/* Sidebar should overlay main content, rather than pushing main content to the right.
+		   Turn off `display: flex` on the body element. */
+		display: block;
+	}
+
+	main {
+		padding-left: 15px;
+		padding-top: 0px;
+	}
+
+	.rustdoc,
+	.main-heading {
+		flex-direction: column;
+	}
+
+	.content .out-of-band {
+		text-align: left;
+		margin-left: initial;
+		padding: initial;
+	}
+
+	.content .out-of-band .since::before {
+		content: "Since ";
+	}
+
+	#copy-path {
+		display: none;
+	}
+
+	/* Hide the logo and item name from the sidebar. Those are displayed
+	   in the mobile-topbar instead. */
+	.sidebar .sidebar-logo,
+	.sidebar .location {
+		display: none;
+	}
+
+	.sidebar-elems {
+		margin-top: 1em;
+	}
+
+	.sidebar {
+		position: fixed;
+		top: 45px;
+		/* Hide the sidebar offscreen while not in use. Doing this instead of display: none means
+		   the sidebar stays visible for screen readers, which is useful for navigation. */
+		left: -1000px;
+		margin-left: 0;
+		margin: 0;
+		padding: 0;
+		z-index: 11;
+		/* Reduce height slightly to account for mobile topbar. */
+		height: calc(100vh - 45px);
+	}
+
+	/* The source view uses a different design for the sidebar toggle, and doesn't have a topbar,
+	   so don't bump down the main content or the sidebar. */
+	.source main,
+	.rustdoc.source .sidebar {
+		top: 0;
+		padding: 0;
+		height: 100vh;
+		border: 0;
+	}
+
+	.sidebar.shown,
+	.source-sidebar-expanded .source .sidebar,
+	.sidebar:focus-within {
+		left: 0;
+	}
+
+	.rustdoc.source > .sidebar {
+		position: fixed;
+		margin: 0;
+		z-index: 11;
+		width: 0;
+	}
+
+	.mobile-topbar .location a {
+		padding: 0;
+		margin: 0;
+	}
+
+	.mobile-topbar .location {
+		border: none;
+		padding: 0;
+		margin: auto 0.5em auto auto;
+		text-overflow: ellipsis;
+		overflow: hidden;
+		white-space: nowrap;
+		/* Rare exception to specifying font sizes in rem. Since the topbar
+		   height is specified in pixels, this also has to be specified in
+		   pixels to avoid overflowing the topbar when the user sets a bigger
+		   font size. */
+		font-size: 24px;
+	}
+
+	.mobile-topbar .logo-container {
+		max-height: 45px;
+	}
+
+	.mobile-topbar .logo-container > img {
+		max-width: 35px;
+		max-height: 35px;
+		margin-left: 20px;
+		margin-top: 5px;
+		margin-bottom: 5px;
+	}
+
+	.mobile-topbar {
+		display: flex;
+		flex-direction: row;
+		position: sticky;
+		z-index: 10;
+		font-size: 2rem;
+		height: 45px;
+		width: 100%;
+		left: 0;
+		top: 0;
+	}
+
+	.source .mobile-topbar {
+		display: none;
+	}
+
+	.sidebar-menu-toggle {
+		width: 45px;
+		/* Rare exception to specifying font sizes in rem. Since this is acting
+		   as an icon, it's okay to specify its sizes in pixels. */
+		font-size: 32px;
+		border: none;
+	}
+
+	.sidebar-elems {
+		background-color: var(--sidebar-background-color);
+	}
+
+	.source nav:not(.sidebar).sub {
+		margin-left: 32px;
+	}
+
+	.content {
+		margin-left: 0px;
+	}
+
+	.source .content {
+		margin-top: 10px;
+	}
+
+	#search {
+		margin-left: 0;
+		padding: 0;
+	}
+
+	.anchor {
+		display: none !important;
+	}
+
+	.notable-traits {
+		position: absolute;
+		left: -22px;
+		top: 24px;
+	}
+
+	#titles > button > div.count {
+		float: left;
+		width: 100%;
+	}
+
+	#titles {
+		height: 50px;
+	}
+
+	/* Because of ios, we need to actually have a full height sidebar title so the
+	 * actual sidebar can show up. But then we need to make it transparent so we don't
+	 * hide content. The filler just allows to create the background for the sidebar
+	 * title. But because of the absolute position, I had to lower the z-index.
+	 */
+	#sidebar-filler {
+		position: fixed;
+		left: 45px;
+		width: calc(100% - 45px);
+		top: 0;
+		height: 45px;
+		z-index: -1;
+		border-bottom: 1px solid;
+	}
+
+	#main-content > details.rustdoc-toggle > summary::before,
+	#main-content > div > details.rustdoc-toggle > summary::before {
+		left: -11px;
+	}
+
+	#sidebar-toggle {
+		position: fixed;
+		left: 1px;
+		top: 100px;
+		width: 30px;
+		font-size: 1.5rem;
+		text-align: center;
+		padding: 0;
+		z-index: 10;
+		border-top-right-radius: 3px;
+		border-bottom-right-radius: 3px;
+		cursor: pointer;
+		font-weight: bold;
+		border: 1px solid;
+		border-left: 0;
+	}
+
+	.source-sidebar-expanded #sidebar-toggle {
+		left: unset;
+		top: unset;
+		width: unset;
+		border-top-right-radius: unset;
+		border-bottom-right-radius: unset;
+		position: sticky;
+		border: 0;
+		border-bottom: 1px solid;
+	}
+
+	#source-sidebar {
+		z-index: 11;
+	}
+
+	#main-content > .line-numbers {
+		margin-top: 0;
+	}
+
+	.notable-traits .notable-traits-tooltiptext {
+		left: 0;
+		top: 100%;
+	}
+
+	/* We don't display the help button on mobile devices. */
+	#help-button {
+		display: none;
+	}
+
+	/* Display an alternating layout on tablets and phones */
+	.item-table {
+		display: block;
+	}
+	.item-row {
+		display: flex;
+		flex-flow: column wrap;
+	}
+	.item-left, .item-right {
+		width: 100%;
+	}
+
+	/* Display an alternating layout on tablets and phones */
+	.search-results > a {
+		border-bottom: 1px solid #aaa9;
+		padding: 5px 0px;
+	}
+	.search-results .result-name, .search-results div.desc, .search-results .result-description {
+		width: 100%;
+	}
+	.search-results div.desc, .search-results .result-description, .item-right {
+		padding-left: 2em;
+	}
+
+	.source-sidebar-expanded .source .sidebar {
+		max-width: 100vw;
+		width: 100vw;
+	}
+
+	/* Position of the "[-]" element. */
+	details.rustdoc-toggle:not(.top-doc) > summary {
+		margin-left: 10px;
+	}
+	.impl-items > details.rustdoc-toggle > summary:not(.hideme)::before,
+	#main-content > details.rustdoc-toggle:not(.top-doc) > summary::before,
+	#main-content > div > details.rustdoc-toggle > summary::before {
+		left: -11px;
+	}
+}
+
+@media print {
+	nav.sidebar, nav.sub, .content .out-of-band, a.srclink, #copy-path,
+	details.rustdoc-toggle[open] > summary::before, details.rustdoc-toggle > summary::before,
+	details.rustdoc-toggle.top-doc > summary {
+		display: none;
+	}
+
+	.docblock {
+		margin-left: 0;
+	}
+
+	main {
+		padding: 10px;
+	}
+}
+
+@media (max-width: 464px) {
+	#titles, #titles > button {
+		height: 73px;
+	}
+
+	#main-content > table:not(.table-display) td {
+		word-break: break-word;
+		width: 50%;
+	}
+
+	#crate-search {
+		border-radius: 4px;
+	}
+
+	.docblock {
+		margin-left: 12px;
+	}
+
+	.docblock code {
+		overflow-wrap: break-word;
+		overflow-wrap: anywhere;
+	}
+
+	.sub-container {
+		flex-direction: column;
+	}
+
+	.sub-logo-container {
+		align-self: center;
+	}
+
+	.source .sub-logo-container > img {
+		height: 35px;
+		width: 35px;
+	}
+
+	#sidebar-toggle {
+		top: 10px;
+	}
+	.source-sidebar-expanded #sidebar-toggle {
+		top: unset;
+	}
+}
+
+.method-toggle summary,
+.implementors-toggle summary,
+.impl {
+	margin-bottom: 0.75em;
+}
+
+.method-toggle[open] {
+	margin-bottom: 2em;
+}
+
+.implementors-toggle[open]  {
+	margin-bottom: 2em;
+}
+
+#trait-implementations-list .method-toggle,
+#synthetic-implementations-list .method-toggle,
+#blanket-implementations-list .method-toggle {
+	margin-bottom: 1em;
+}
+
+/* Begin: styles for --scrape-examples feature */
+
+.scraped-example-list .scrape-help {
+	margin-left: 10px;
+	padding: 0 4px;
+	font-weight: normal;
+	font-size: 12px;
+	position: relative;
+	bottom: 1px;
+	background: transparent;
+	border-width: 1px;
+	border-style: solid;
+	border-radius: 50px;
+}
+
+.scraped-example .code-wrapper {
+	position: relative;
+	display: flex;
+	flex-direction: row;
+	flex-wrap: wrap;
+	width: 100%;
+}
+
+.scraped-example:not(.expanded) .code-wrapper {
+	max-height: 240px;
+}
+
+.scraped-example:not(.expanded) .code-wrapper pre {
+	overflow-y: hidden;
+	max-height: 240px;
+	padding-bottom: 0;
+}
+
+.scraped-example:not(.expanded) .code-wrapper pre.line-numbers {
+	overflow-x: hidden;
+}
+
+.scraped-example .code-wrapper .prev {
+	position: absolute;
+	top: 0.25em;
+	right: 2.25em;
+	z-index: 100;
+	cursor: pointer;
+}
+
+.scraped-example .code-wrapper .next {
+	position: absolute;
+	top: 0.25em;
+	right: 1.25em;
+	z-index: 100;
+	cursor: pointer;
+}
+
+.scraped-example .code-wrapper .expand {
+	position: absolute;
+	top: 0.25em;
+	right: 0.25em;
+	z-index: 100;
+	cursor: pointer;
+}
+
+.scraped-example:not(.expanded) .code-wrapper:before {
+	content: " ";
+	width: 100%;
+	height: 5px;
+	position: absolute;
+	z-index: 100;
+	top: 0;
+}
+
+.scraped-example:not(.expanded) .code-wrapper:after {
+	content: " ";
+	width: 100%;
+	height: 5px;
+	position: absolute;
+	z-index: 100;
+	bottom: 0;
+}
+
+.scraped-example .code-wrapper .line-numbers {
+	margin: 0;
+	padding: 14px 0;
+}
+
+.scraped-example .code-wrapper .line-numbers span {
+	padding: 0 14px;
+}
+
+.scraped-example .code-wrapper .example-wrap {
+	flex: 1;
+	overflow-x: auto;
+	overflow-y: hidden;
+	margin-bottom: 0;
+}
+
+.scraped-example:not(.expanded) .code-wrapper .example-wrap {
+	overflow-x: hidden;
+}
+
+.scraped-example .code-wrapper .example-wrap pre.rust {
+	overflow-x: inherit;
+	width: inherit;
+	overflow-y: hidden;
+}
+
+
+.more-examples-toggle {
+	max-width: calc(100% + 25px);
+	margin-top: 10px;
+	margin-left: -25px;
+}
+
+.more-examples-toggle .hide-more {
+	margin-left: 25px;
+	margin-bottom: 5px;
+	cursor: pointer;
+}
+
+.more-scraped-examples {
+	margin-left: 5px;
+	display: flex;
+	flex-direction: row;
+}
+
+.more-scraped-examples-inner {
+	/* 20px is width of toggle-line + toggle-line-inner */
+	width: calc(100% - 20px);
+}
+
+.toggle-line {
+	align-self: stretch;
+	margin-right: 10px;
+	margin-top: 5px;
+	padding: 0 4px;
+	cursor: pointer;
+}
+
+.toggle-line-inner {
+	min-width: 2px;
+	height: 100%;
+}
+
+.more-scraped-examples .scraped-example {
+	margin-bottom: 20px;
+}
+
+.more-scraped-examples .scraped-example:last-child {
+	margin-bottom: 0;
+}
+
+.example-links a {
+	margin-top: 20px;
+}
+
+.example-links ul {
+	margin-bottom: 0;
+}
+
+/* End: styles for --scrape-examples feature */
diff --git a/src/librustdoc/html/static/css/settings.css b/src/librustdoc/html/static/css/settings.css
new file mode 100644
index 000000000..e82ec0426
--- /dev/null
+++ b/src/librustdoc/html/static/css/settings.css
@@ -0,0 +1,90 @@
+.setting-line {
+	margin: 0.6em 0 0.6em 0.3em;
+	position: relative;
+}
+
+.setting-line .choices {
+	display: flex;
+	flex-wrap: wrap;
+}
+
+.setting-line .radio-line input {
+	margin-right: 0.3em;
+	height: 1.2rem;
+	width: 1.2rem;
+	border: 1px solid;
+	outline: none;
+	-webkit-appearance: none;
+	cursor: pointer;
+	border-radius: 50%;
+}
+.setting-line .radio-line input + span {
+	padding-bottom: 1px;
+}
+
+.radio-line .setting-name {
+	width: 100%;
+}
+
+.radio-line .choice {
+	margin-top: 0.1em;
+	margin-bottom: 0.1em;
+	min-width: 3.8em;
+	padding: 0.3em;
+	display: flex;
+	align-items: center;
+	cursor: pointer;
+}
+.radio-line .choice + .choice {
+	margin-left: 0.5em;
+}
+
+.toggle {
+	position: relative;
+	width: 100%;
+	margin-right: 20px;
+	display: flex;
+	align-items: center;
+	cursor: pointer;
+}
+
+.toggle input {
+	opacity: 0;
+	position: absolute;
+}
+
+.slider {
+	position: relative;
+	width: 45px;
+	min-width: 45px;
+	display: block;
+	height: 28px;
+	margin-right: 20px;
+	cursor: pointer;
+	background-color: #ccc;
+	transition: .3s;
+}
+
+.slider:before {
+	position: absolute;
+	content: "";
+	height: 19px;
+	width: 19px;
+	left: 4px;
+	bottom: 4px;
+	transition: .3s;
+}
+
+input:checked + .slider:before {
+	transform: translateX(19px);
+}
+
+.setting-line > .sub-settings {
+	padding-left: 42px;
+	width: 100%;
+	display: block;
+}
+
+#settings .setting-line {
+	margin: 1.2em 0.6em;
+}
diff --git a/src/librustdoc/html/static/css/themes/ayu.css b/src/librustdoc/html/static/css/themes/ayu.css
new file mode 100644
index 000000000..c42cac59b
--- /dev/null
+++ b/src/librustdoc/html/static/css/themes/ayu.css
@@ -0,0 +1,563 @@
+/*
+Based off of the Ayu theme
+Original by Dempfi (https://github.com/dempfi/ayu)
+*/
+
+:root {
+	--main-background-color: #0f1419;
+	--main-color: #c5c5c5;
+	--settings-input-color: #ffb454;
+	--sidebar-background-color: #14191f;
+	--sidebar-background-color-hover: rgba(70, 70, 70, 0.33);
+	--code-block-background-color: #191f26;
+	--scrollbar-track-background-color: transparent;
+	--scrollbar-thumb-background-color: #5c6773;
+	--scrollbar-color: #5c6773 #24292f;
+	--headings-border-bottom-color: #5c6773;
+}
+
+.slider {
+	background-color: #ccc;
+}
+.slider:before {
+	background-color: white;
+}
+input:focus + .slider {
+	box-shadow: 0 0 0 2px #0a84ff, 0 0 0 6px rgba(10, 132, 255, 0.3);
+}
+
+h1, h2, h3, h4 {
+	color: white;
+}
+h1.fqn  a {
+	color: #fff;
+}
+h4 {
+	border: none;
+}
+
+.in-band {
+	background-color: #0f1419;
+}
+
+.docblock code {
+	color: #ffb454;
+}
+.code-header {
+	color: #e6e1cf;
+}
+.docblock pre > code, pre > code {
+	color: #e6e1cf;
+}
+span code {
+	color: #e6e1cf;
+}
+.docblock a > code {
+	color: #39AFD7 !important;
+}
+pre, .rustdoc.source .example-wrap {
+	color: #e6e1cf;
+}
+
+.rust-logo {
+	filter: drop-shadow(1px 0 0px #fff)
+		drop-shadow(0 1px 0 #fff)
+		drop-shadow(-1px 0 0 #fff)
+		drop-shadow(0 -1px 0 #fff);
+}
+
+.sidebar .current,
+.sidebar a:hover {
+	background-color: transparent;
+	color: #ffb44c;
+}
+
+.sidebar-elems .location {
+	color: #ff7733;
+}
+
+.line-numbers span { color: #5c6773; }
+.line-numbers .line-highlighted {
+	color: #708090;
+	background-color: rgba(255, 236, 164, 0.06);
+	padding-right: 4px;
+	border-right: 1px solid #ffb44c;
+}
+
+.docblock table td, .docblock table th {
+	border-color: #5c6773;
+}
+
+.search-results a:hover {
+	background-color: #777;
+}
+
+.search-results a:focus {
+	color: #000 !important;
+	background-color: #c6afb3;
+}
+.search-results a {
+	color: #0096cf;
+}
+.search-results a div.desc {
+	color: #c5c5c5;
+}
+
+.content .item-info::before { color: #ccc; }
+
+.content span.foreigntype, .content a.foreigntype { color: #ffa0a5; }
+.content span.union, .content a.union { color: #ffa0a5; }
+.content span.constant, .content a.constant,
+.content span.static, .content a.static { color: #39AFD7; }
+.content span.primitive, .content a.primitive { color: #ffa0a5; }
+.content span.traitalias, .content a.traitalias { color: #39AFD7; }
+.content span.keyword, .content a.keyword { color: #39AFD7; }
+
+.content span.externcrate, .content span.mod, .content a.mod {
+	color: #39AFD7;
+}
+.content span.struct, .content a.struct {
+	color: #ffa0a5;
+}
+.content span.enum, .content a.enum {
+	color: #ffa0a5;
+}
+.content span.trait, .content a.trait {
+	color: #39AFD7;
+}
+.content span.type, .content a.type {
+	color: #39AFD7;
+}
+.content span.type,
+.content a.type,
+.block a.current.type { color: #39AFD7; }
+.content span.associatedtype,
+.content a.associatedtype,
+.block a.current.associatedtype { color: #39AFD7; }
+.content span.fn, .content a.fn, .content span.method,
+.content a.method, .content span.tymethod,
+.content a.tymethod, .content .fnname {
+	color: #fdd687;
+}
+.content span.attr, .content a.attr, .content span.derive,
+.content a.derive, .content span.macro, .content a.macro {
+	color: #a37acc;
+}
+
+.sidebar a { color: #53b1db; }
+.sidebar a.current.type { color: #53b1db; }
+.sidebar a.current.associatedtype { color: #53b1db; }
+
+pre.rust .comment { color: #788797; }
+pre.rust .doccomment { color: #a1ac88; }
+
+nav.main .current {
+	border-top-color: #5c6773;
+	border-bottom-color: #5c6773;
+}
+nav.main .separator {
+	border: 1px solid #5c6773;
+}
+a {
+	color: #39AFD7;
+}
+
+.sidebar h2 a,
+.sidebar h3 a {
+	color: white;
+}
+.search-results a {
+	color: #0096cf;
+}
+body.source .example-wrap pre.rust a {
+	background: #333;
+}
+
+details.rustdoc-toggle > summary.hideme > span,
+details.rustdoc-toggle > summary::before {
+	color: #999;
+}
+
+details.rustdoc-toggle > summary::before {
+	filter: invert(100%);
+}
+
+#crate-search, .search-input {
+	background-color: #141920;
+	border-color: #424c57;
+}
+
+#crate-search {
+	/* Without the `!important`, the border-color is ignored for `<select>`...
+	   It cannot be in the group above because `.search-input` has a different border color on
+	   hover. */
+	border-color: #424c57 !important;
+}
+
+.search-input {
+	color: #ffffff;
+}
+
+.module-item .stab,
+.import-item .stab {
+	color: #000;
+}
+
+/* Created this empty rule to satisfy the theme checks. */
+.stab.empty-impl {}
+.stab.must_implement {}
+
+.stab.unstable,
+.stab.deprecated,
+.stab.portability,
+.stab.empty-impl,
+.stab.must_implement {
+	color: #c5c5c5;
+	background: #314559 !important;
+	border-style: none !important;
+	border-radius: 4px;
+	padding: 3px 6px 3px 6px;
+}
+
+.stab.portability > code {
+	color: #e6e1cf;
+	background: none;
+}
+
+.rightside,
+.out-of-band {
+	color: grey;
+}
+
+.result-name .primitive > i, .result-name .keyword > i {
+	color: #788797;
+}
+
+.line-numbers :target { background-color: transparent; }
+
+/* Code highlighting */
+pre.rust .number, pre.rust .string { color: #b8cc52; }
+pre.rust .kw, pre.rust .kw-2, pre.rust .prelude-ty,
+pre.rust .bool-val, pre.rust .prelude-val,
+pre.rust .op, pre.rust .lifetime { color: #ff7733; }
+pre.rust .macro, pre.rust .macro-nonterminal { color: #a37acc; }
+pre.rust .question-mark {
+	color: #ff9011;
+}
+pre.rust .self {
+	color: #36a3d9;
+	font-style: italic;
+}
+pre.rust .attribute {
+	color: #e6e1cf;
+}
+pre.rust .attribute .ident, pre.rust .attribute .op {
+	color: #e6e1cf;
+}
+
+.example-wrap > pre.line-number {
+	color: #5c67736e;
+	border: none;
+}
+
+a.test-arrow {
+	font-size: 100%;
+	color: #788797;
+	border-radius: 4px;
+	background-color: rgba(57, 175, 215, 0.09);
+}
+
+a.test-arrow:hover {
+	background-color: rgba(57, 175, 215, 0.368);
+	color: #c5c5c5;
+}
+
+.toggle-label,
+.code-attribute {
+	color: #999;
+}
+
+:target {
+	background: rgba(255, 236, 164, 0.06);
+	border-right: 3px solid rgba(255, 180, 76, 0.85);
+}
+
+pre.compile_fail {
+	border-left: 2px solid rgba(255,0,0,.4);
+}
+
+pre.compile_fail:hover, .information:hover + pre.compile_fail {
+	border-left: 2px solid #f00;
+}
+
+pre.should_panic {
+	border-left: 2px solid rgba(255,0,0,.4);
+}
+
+pre.should_panic:hover, .information:hover + pre.should_panic {
+	border-left: 2px solid #f00;
+}
+
+pre.ignore {
+	border-left: 2px solid rgba(255,142,0,.6);
+}
+
+pre.ignore:hover, .information:hover + pre.ignore {
+	border-left: 2px solid #ff9200;
+}
+
+.tooltip.compile_fail {
+	color: rgba(255,0,0,.5);
+}
+
+.information > .compile_fail:hover {
+	color: #f00;
+}
+
+.tooltip.should_panic {
+	color: rgba(255,0,0,.5);
+}
+
+.information > .should_panic:hover {
+	color: #f00;
+}
+
+.tooltip.ignore {
+	color: rgba(255,142,0,.6);
+}
+
+.information > .ignore:hover {
+	color: #ff9200;
+}
+
+.search-failed a {
+	color: #39AFD7;
+}
+
+.tooltip::after {
+	background-color: #314559;
+	color: #c5c5c5;
+	border: 1px solid #5c6773;
+}
+
+.tooltip::before {
+	border-color: transparent #314559 transparent transparent;
+}
+
+.notable-traits-tooltiptext {
+	background-color: #314559;
+	border-color: #5c6773;
+}
+
+.notable-traits-tooltiptext .notable {
+	border-bottom-color: #5c6773;
+}
+
+#titles > button.selected {
+	background-color: #141920 !important;
+	border-bottom: 1px solid #ffb44c !important;
+	border-top: none;
+}
+
+#titles > button:not(.selected) {
+	background-color: transparent !important;
+	border: none;
+}
+
+#titles > button:hover {
+	border-bottom: 1px solid rgba(242, 151, 24, 0.3);
+}
+
+#titles > button > div.count {
+	color: #888;
+}
+
+/* rules that this theme does not need to set, here to satisfy the rule checker */
+/* note that a lot of these are partially set in some way (meaning they are set
+individually rather than as a group) */
+/* FIXME: these rules should be at the bottom of the file but currently must be
+above the `@media (max-width: 700px)` rules due to a bug in the css checker */
+/* see https://github.com/rust-lang/rust/pull/71237#issuecomment-618170143 */
+.search-input:focus {}
+.content span.attr,.content a.attr,.block a.current.attr,.content span.derive,.content a.derive,
+.block a.current.derive,.content span.macro,.content a.macro,.block a.current.macro {}
+.content span.struct,.content a.struct,.block a.current.struct {}
+#titles>button:hover,#titles>button.selected {}
+.content span.typedef,.content a.typedef,.block a.current.typedef {}
+.content span.union,.content a.union,.block a.current.union {}
+pre.rust .lifetime {}
+.stab.unstable {}
+h2,
+h3:not(.impl):not(.method):not(.type):not(.tymethod), h4:not(.method):not(.type):not(.tymethod) {}
+.content span.enum,.content a.enum,.block a.current.enum {}
+.content span.constant,.content a.constant,.block a.current.constant,.content span.static,
+.content a.static, .block a.current.static {}
+.content span.keyword,.content a.keyword,.block a.current.keyword {}
+pre.rust .comment {}
+.content span.traitalias,.content a.traitalias,.block a.current.traitalias {}
+.content span.fn,.content a.fn,.block a.current.fn,.content span.method,.content a.method,
+.block a.current.method,.content span.tymethod,.content a.tymethod,.block a.current.tymethod,
+.content .fnname {}
+pre.rust .kw {}
+pre.rust .self,pre.rust .bool-val,pre.rust .prelude-val,pre.rust .attribute,
+pre.rust .attribute .ident {}
+.content span.foreigntype,.content a.foreigntype,.block a.current.foreigntype {}
+pre.rust .doccomment {}
+.stab.deprecated {}
+.content a.attr,.content a.derive,.content a.macro {}
+.stab.portability {}
+.content span.primitive,.content a.primitive,.block a.current.primitive {}
+.content span.externcrate,.content span.mod,.content a.mod,.block a.current.mod {}
+pre.rust .kw-2,pre.rust .prelude-ty {}
+.content span.trait,.content a.trait,.block a.current.trait {}
+
+.search-results a:focus span {}
+a.result-trait:focus {}
+a.result-traitalias:focus {}
+a.result-mod:focus,
+a.result-externcrate:focus {}
+a.result-mod:focus {}
+a.result-externcrate:focus {}
+a.result-enum:focus {}
+a.result-struct:focus {}
+a.result-union:focus {}
+a.result-fn:focus,
+a.result-method:focus,
+a.result-tymethod:focus {}
+a.result-type:focus {}
+a.result-associatedtype:focus {}
+a.result-foreigntype:focus {}
+a.result-attr:focus,
+a.result-derive:focus,
+a.result-macro:focus {}
+a.result-constant:focus,
+a.result-static:focus {}
+a.result-primitive:focus {}
+a.result-keyword:focus {}
+
+.sidebar a.current.enum {}
+.sidebar a.current.struct {}
+.sidebar a.current.foreigntype {}
+.sidebar a.current.attr,
+.sidebar a.current.derive,
+.sidebar a.current.macro {}
+.sidebar a.current.union {}
+.sidebar a.current.constant
+.sidebar a.current.static {}
+.sidebar a.current.primitive {}
+.sidebar a.current.externcrate
+.sidebar a.current.mod {}
+.sidebar a.current.trait {}
+.sidebar a.current.traitalias {}
+.sidebar a.current.fn,
+.sidebar a.current.method,
+.sidebar a.current.tymethod {}
+.sidebar a.current.keyword {}
+
+@media (max-width: 700px) {
+	.sidebar-elems {
+		border-right-color: #5c6773;
+	}
+}
+
+kbd {
+	color: #c5c5c5;
+	background-color: #314559;
+	border-color: #5c6773;
+	border-bottom-color: #5c6773;
+	box-shadow: inset 0 -1px 0 #5c6773;
+}
+
+#settings-menu > a, #help-button > button {
+	border-color: #5c6773;
+	background-color: #0f1419;
+	color: #fff;
+}
+
+#settings-menu > a img {
+	filter: invert(100);
+}
+
+.popover, .popover::before,
+#help-button span.top, #help-button span.bottom {
+	border-color: #5c6773;
+}
+
+#copy-path {
+	color: #fff;
+}
+#copy-path > img {
+	filter: invert(70%);
+}
+#copy-path:hover > img {
+	filter: invert(100%);
+}
+
+#settings-menu > a:hover, #settings-menu > a:focus,
+#help-button > button:hover, #help-button > button:focus {
+	border-color: #e0e0e0;
+}
+
+#theme-choices {
+	border-color: #5c6773;
+	background-color: #0f1419;
+}
+
+#theme-choices > button:not(:first-child) {
+	border-top-color: #5c6773;
+}
+
+#theme-choices > button:hover, #theme-choices > button:focus {
+	background-color: rgba(110, 110, 110, 0.33);
+}
+
+.search-results .result-name span.alias {
+	color: #c5c5c5;
+}
+.search-results .result-name span.grey {
+	color: #999;
+}
+
+#source-sidebar > .title {
+	color: #fff;
+	border-bottom-color: #5c6773;
+}
+#source-sidebar div.files > a:hover, details.dir-entry summary:hover,
+#source-sidebar div.files > a:focus, details.dir-entry summary:focus {
+	background-color: #14191f;
+	color: #ffb44c;
+}
+#source-sidebar div.files > a.selected {
+	background-color: #14191f;
+	color: #ffb44c;
+}
+
+.scraped-example-list .scrape-help {
+	border-color: #aaa;
+	color: #eee;
+}
+.scraped-example-list .scrape-help:hover {
+	border-color: white;
+	color: white;
+}
+.more-examples-toggle summary, .more-examples-toggle .hide-more {
+	color: #999;
+}
+.scraped-example .example-wrap .rust span.highlight {
+	background: rgb(91, 59, 1);
+}
+.scraped-example .example-wrap .rust span.highlight.focus {
+	background: rgb(124, 75, 15);
+}
+.scraped-example:not(.expanded) .code-wrapper:before {
+	background: linear-gradient(to bottom, rgba(15, 20, 25, 1), rgba(15, 20, 25, 0));
+}
+.scraped-example:not(.expanded) .code-wrapper:after {
+	background: linear-gradient(to top, rgba(15, 20, 25, 1), rgba(15, 20, 25, 0));
+}
+.toggle-line-inner {
+	background: #999;
+}
+.toggle-line:hover .toggle-line-inner {
+	background: #c5c5c5;
+}
diff --git a/src/librustdoc/html/static/css/themes/dark.css b/src/librustdoc/html/static/css/themes/dark.css
new file mode 100644
index 000000000..a550eb1c1
--- /dev/null
+++ b/src/librustdoc/html/static/css/themes/dark.css
@@ -0,0 +1,409 @@
+:root {
+	--main-background-color: #353535;
+	--main-color: #ddd;
+	--settings-input-color: #2196f3;
+	--sidebar-background-color: #505050;
+	--sidebar-background-color-hover: #676767;
+	--code-block-background-color: #2A2A2A;
+	--scrollbar-track-background-color: #717171;
+	--scrollbar-thumb-background-color: rgba(32, 34, 37, .6);
+	--scrollbar-color: rgba(32,34,37,.6) #5a5a5a;
+	--headings-border-bottom-color: #d2d2d2;
+}
+
+.slider {
+	background-color: #ccc;
+}
+.slider:before {
+	background-color: white;
+}
+input:focus + .slider {
+	box-shadow: 0 0 0 2px #0a84ff, 0 0 0 6px rgba(10, 132, 255, 0.3);
+}
+
+.in-band {
+	background-color: #353535;
+}
+
+.rust-logo {
+	filter: drop-shadow(1px 0 0px #fff)
+		drop-shadow(0 1px 0 #fff)
+		drop-shadow(-1px 0 0 #fff)
+		drop-shadow(0 -1px 0 #fff)
+}
+
+.sidebar .current,
+.sidebar a:hover {
+	background: #444;
+}
+
+.line-numbers span { color: #3B91E2; }
+.line-numbers .line-highlighted {
+	background-color: #0a042f !important;
+}
+
+.docblock table td, .docblock table th {
+	border-color: #ddd;
+}
+
+.search-results a:hover {
+	background-color: #777;
+}
+
+.search-results a:focus {
+	color: #eee !important;
+	background-color: #616161;
+}
+.search-results a:focus span { color: #eee !important; }
+a.result-trait:focus { background-color: #013191; }
+a.result-traitalias:focus { background-color: #013191; }
+a.result-mod:focus,
+a.result-externcrate:focus { background-color: #884719; }
+a.result-enum:focus { background-color: #194e9f; }
+a.result-struct:focus { background-color: #194e9f; }
+a.result-union:focus { background-color: #194e9f; }
+a.result-fn:focus,
+a.result-method:focus,
+a.result-tymethod:focus { background-color: #4950ed; }
+a.result-type:focus { background-color: #194e9f; }
+a.result-associatedtype:focus { background-color: #884719; }
+a.result-foreigntype:focus { background-color: #194e9f; }
+a.result-attr:focus,
+a.result-derive:focus,
+a.result-macro:focus { background-color: #217d1c; }
+a.result-constant:focus,
+a.result-static:focus { background-color: #884719; }
+a.result-primitive:focus { background-color: #194e9f; }
+a.result-keyword:focus { background-color: #884719; }
+
+.content .item-info::before { color: #ccc; }
+
+.content span.enum, .content a.enum, .block a.current.enum { color: #2dbfb8; }
+.content span.struct, .content a.struct, .block a.current.struct { color: #2dbfb8; }
+.content span.type, .content a.type, .block a.current.type { color: #2dbfb8; }
+.content span.associatedtype,
+.content a.associatedtype,
+.block a.current.associatedtype { color: #D2991D; }
+.content span.foreigntype, .content a.foreigntype, .block a.current.foreigntype { color: #2dbfb8; }
+.content span.attr, .content a.attr, .block a.current.attr,
+.content span.derive, .content a.derive, .block a.current.derive,
+.content span.macro, .content a.macro, .block a.current.macro { color: #09bd00; }
+.content span.union, .content a.union, .block a.current.union { color: #2dbfb8; }
+.content span.constant, .content a.constant, .block a.current.constant,
+.content span.static, .content a.static, .block a.current.static { color: #D2991D; }
+.content span.primitive, .content a.primitive, .block a.current.primitive { color: #2dbfb8; }
+.content span.externcrate,
+.content span.mod, .content a.mod, .block a.current.mod { color: #D2991D; }
+.content span.trait, .content a.trait, .block a.current.trait { color: #b78cf2; }
+.content span.traitalias, .content a.traitalias, .block a.current.traitalias { color: #b78cf2; }
+.content span.fn, .content a.fn, .block a.current.fn,
+.content span.method, .content a.method, .block a.current.method,
+.content span.tymethod, .content a.tymethod, .block a.current.tymethod,
+.content .fnname{ color: #2BAB63; }
+.content span.keyword, .content a.keyword, .block a.current.keyword { color: #D2991D; }
+
+.sidebar a { color: #fdbf35; }
+.sidebar a.current.enum { color: #12ece2; }
+.sidebar a.current.struct { color: #12ece2; }
+.sidebar a.current.type { color: #12ece2; }
+.sidebar a.current.associatedtype { color: #fdbf35; }
+.sidebar a.current.foreigntype { color: #12ece2; }
+.sidebar a.current.attr,
+.sidebar a.current.derive,
+.sidebar a.current.macro { color: #0be900; }
+.sidebar a.current.union { color: #12ece2; }
+.sidebar a.current.constant
+.sidebar a.current.static { color: #fdbf35; }
+.sidebar a.current.primitive { color: #12ece2; }
+.sidebar a.current.externcrate
+.sidebar a.current.mod { color: #fdbf35; }
+.sidebar a.current.trait { color: #cca7ff; }
+.sidebar a.current.traitalias { color: #cca7ff; }
+.sidebar a.current.fn,
+.sidebar a.current.method,
+.sidebar a.current.tymethod { color: #32d479; }
+.sidebar a.current.keyword { color: #fdbf35; }
+
+pre.rust .comment { color: #8d8d8b; }
+pre.rust .doccomment { color: #8ca375; }
+
+nav.main .current {
+	border-top-color: #eee;
+	border-bottom-color: #eee;
+}
+nav.main .separator {
+	border-color: #eee;
+}
+
+a {
+	color: #D2991D;
+}
+
+body.source .example-wrap pre.rust a {
+	background: #333;
+}
+
+details.rustdoc-toggle > summary.hideme > span,
+details.rustdoc-toggle > summary::before {
+	color: #999;
+}
+
+details.rustdoc-toggle > summary::before {
+	filter: invert(100%);
+}
+
+#crate-search, .search-input {
+	color: #111;
+	background-color: #f0f0f0;
+	border-color: #f0f0f0;
+}
+
+#crate-search {
+	/* Without the `!important`, the border-color is ignored for `<select>`...
+	   It cannot be in the group above because `.search-input` has a different border color on
+	   hover. */
+	border-color: #f0f0f0 !important;
+}
+
+.search-input {
+	border-color: #e0e0e0;
+}
+
+.search-input:focus {
+	border-color: #008dfd;
+}
+
+.stab.empty-impl { background: #FFF5D6; border-color: #FFC600; color: #2f2f2f; }
+.stab.unstable { background: #FFF5D6; border-color: #FFC600; color: #2f2f2f; }
+.stab.deprecated { background: #ffc4c4; border-color: #db7b7b; color: #2f2f2f; }
+.stab.must_implement { background: #F3DFFF; border-color: #b07bdb; color: #2f2f2f; }
+.stab.portability { background: #F3DFFF; border-color: #b07bdb; color: #2f2f2f; }
+.stab.portability > code { background: none; }
+
+.rightside,
+.out-of-band {
+	color: grey;
+}
+
+.line-numbers :target { background-color: transparent; }
+
+/* Code highlighting */
+pre.rust .kw { color: #ab8ac1; }
+pre.rust .kw-2, pre.rust .prelude-ty { color: #769acb; }
+pre.rust .number, pre.rust .string { color: #83a300; }
+pre.rust .self, pre.rust .bool-val, pre.rust .prelude-val,
+pre.rust .attribute, pre.rust .attribute .ident { color: #ee6868; }
+pre.rust .macro, pre.rust .macro-nonterminal { color: #3E999F; }
+pre.rust .lifetime { color: #d97f26; }
+pre.rust .question-mark {
+	color: #ff9011;
+}
+
+.example-wrap > pre.line-number {
+	border-color: #4a4949;
+}
+
+a.test-arrow {
+	color: #dedede;
+	background-color: rgba(78, 139, 202, 0.2);
+}
+
+a.test-arrow:hover{
+	background-color: #4e8bca;
+}
+
+.toggle-label,
+.code-attribute {
+	color: #999;
+}
+
+:target {
+	background-color: #494a3d;
+	border-right: 3px solid #bb7410;
+}
+
+pre.compile_fail {
+	border-left: 2px solid rgba(255,0,0,.8);
+}
+
+pre.compile_fail:hover, .information:hover + pre.compile_fail {
+	border-left: 2px solid #f00;
+}
+
+pre.should_panic {
+	border-left: 2px solid rgba(255,0,0,.8);
+}
+
+pre.should_panic:hover, .information:hover + pre.should_panic {
+	border-left: 2px solid #f00;
+}
+
+pre.ignore {
+	border-left: 2px solid rgba(255,142,0,.6);
+}
+
+pre.ignore:hover, .information:hover + pre.ignore {
+	border-left: 2px solid #ff9200;
+}
+
+.tooltip.compile_fail {
+	color: rgba(255,0,0,.8);
+}
+
+.information > .compile_fail:hover {
+	color: #f00;
+}
+
+.tooltip.should_panic {
+	color: rgba(255,0,0,.8);
+}
+
+.information > .should_panic:hover {
+	color: #f00;
+}
+
+.tooltip.ignore {
+	color: rgba(255,142,0,.6);
+}
+
+.information > .ignore:hover {
+	color: #ff9200;
+}
+
+.search-failed a {
+	color: #0089ff;
+}
+
+.tooltip::after {
+	background-color: #000;
+	color: #fff;
+	border-color: #000;
+}
+
+.tooltip::before {
+	border-color: transparent black transparent transparent;
+}
+
+.notable-traits-tooltiptext {
+	background-color: #111;
+	border-color: #777;
+}
+
+.notable-traits-tooltiptext .notable {
+	border-bottom-color: #d2d2d2;
+}
+
+#titles > button:not(.selected) {
+	background-color: #252525;
+	border-top-color: #252525;
+}
+
+#titles > button:hover, #titles > button.selected {
+	border-top-color: #0089ff;
+	background-color: #353535;
+}
+
+#titles > button > div.count {
+	color: #888;
+}
+
+@media (max-width: 700px) {
+	.sidebar-elems {
+		border-right-color: #000;
+	}
+}
+
+kbd {
+	color: #000;
+	background-color: #fafbfc;
+	border-color: #d1d5da;
+	border-bottom-color: #c6cbd1;
+	box-shadow: inset 0 -1px 0 #c6cbd1;
+}
+
+#settings-menu > a, #help-button > button {
+	border-color: #e0e0e0;
+	background: #f0f0f0;
+	color: #000;
+}
+
+#settings-menu > a:hover, #settings-menu > a:focus,
+#help-button > button:hover, #help-button > button:focus {
+	border-color: #ffb900;
+}
+
+.popover, .popover::before,
+#help-button span.top, #help-button span.bottom {
+	border-color: #d2d2d2;
+}
+
+#copy-path {
+	color: #999;
+}
+#copy-path > img {
+	filter: invert(50%);
+}
+#copy-path:hover > img {
+	filter: invert(65%);
+}
+
+#theme-choices {
+	border-color: #e0e0e0;
+	background-color: #353535;
+}
+
+#theme-choices > button:not(:first-child) {
+	border-top-color: #e0e0e0;
+}
+
+#theme-choices > button:hover, #theme-choices > button:focus {
+	background-color: #4e4e4e;
+}
+
+.search-results .result-name span.alias {
+	color: #fff;
+}
+.search-results .result-name span.grey {
+	color: #ccc;
+}
+
+#source-sidebar > .title {
+	border-bottom-color: #ccc;
+}
+#source-sidebar div.files > a:hover, details.dir-entry summary:hover,
+#source-sidebar div.files > a:focus, details.dir-entry summary:focus {
+	background-color: #444;
+}
+#source-sidebar div.files > a.selected {
+	background-color: #333;
+}
+
+.scraped-example-list .scrape-help {
+	border-color: #aaa;
+	color: #eee;
+}
+.scraped-example-list .scrape-help:hover {
+	border-color: white;
+	color: white;
+}
+.more-examples-toggle summary, .more-examples-toggle .hide-more {
+	color: #999;
+}
+.scraped-example .example-wrap .rust span.highlight {
+	background: rgb(91, 59, 1);
+}
+.scraped-example .example-wrap .rust span.highlight.focus {
+	background: rgb(124, 75, 15);
+}
+.scraped-example:not(.expanded) .code-wrapper:before {
+	background: linear-gradient(to bottom, rgba(53, 53, 53, 1), rgba(53, 53, 53, 0));
+}
+.scraped-example:not(.expanded) .code-wrapper:after {
+	background: linear-gradient(to top, rgba(53, 53, 53, 1), rgba(53, 53, 53, 0));
+}
+.toggle-line-inner {
+	background: #999;
+}
+.toggle-line:hover .toggle-line-inner {
+	background: #c5c5c5;
+}
diff --git a/src/librustdoc/html/static/css/themes/light.css b/src/librustdoc/html/static/css/themes/light.css
new file mode 100644
index 000000000..b751acff1
--- /dev/null
+++ b/src/librustdoc/html/static/css/themes/light.css
@@ -0,0 +1,395 @@
+:root {
+	--main-background-color: white;
+	--main-color: black;
+	--settings-input-color: #2196f3;
+	--sidebar-background-color: #F5F5F5;
+	--sidebar-background-color-hover: #E0E0E0;
+	--code-block-background-color: #F5F5F5;
+	--scrollbar-track-background-color: #dcdcdc;
+	--scrollbar-thumb-background-color: rgba(36, 37, 39, 0.6);
+	--scrollbar-color: rgba(36, 37, 39, 0.6) #d9d9d9;
+	--headings-border-bottom-color: #ddd;
+}
+
+.slider {
+	background-color: #ccc;
+}
+.slider:before {
+	background-color: white;
+}
+input:focus + .slider {
+	box-shadow: 0 0 0 2px #0a84ff, 0 0 0 6px rgba(10, 132, 255, 0.3);
+}
+
+.in-band {
+	background-color: white;
+}
+
+.rust-logo {
+	/* This rule exists to force other themes to explicitly style the logo.
+	 * Rustdoc has a custom linter for this purpose.
+	 */
+}
+
+.sidebar .current,
+.sidebar a:hover {
+	background-color: #fff;
+}
+
+.line-numbers span { color: #c67e2d; }
+.line-numbers .line-highlighted {
+	background-color: #FDFFD3 !important;
+}
+
+.docblock table td, .docblock table th {
+	border-color: #ddd;
+}
+
+.search-results a:hover {
+	background-color: #ddd;
+}
+
+.search-results a:focus {
+	color: #000 !important;
+	background-color: #ccc;
+}
+.search-results a:focus span { color: #000 !important; }
+a.result-trait:focus { background-color: #c7b6ff; }
+a.result-traitalias:focus { background-color: #c7b6ff; }
+a.result-mod:focus,
+a.result-externcrate:focus { background-color: #afc6e4; }
+a.result-enum:focus { background-color: #e7b1a0; }
+a.result-struct:focus { background-color: #e7b1a0; }
+a.result-union:focus { background-color: #e7b1a0; }
+a.result-fn:focus,
+a.result-method:focus,
+a.result-tymethod:focus { background-color: #c6afb3; }
+a.result-type:focus { background-color: #e7b1a0; }
+a.result-associatedtype:focus { background-color: #afc6e4; }
+a.result-foreigntype:focus { background-color: #e7b1a0; }
+a.result-attr:focus,
+a.result-derive:focus,
+a.result-macro:focus { background-color: #8ce488; }
+a.result-constant:focus,
+a.result-static:focus { background-color: #afc6e4; }
+a.result-primitive:focus { background-color: #e7b1a0; }
+a.result-keyword:focus { background-color: #afc6e4; }
+
+.content .item-info::before { color: #ccc; }
+
+.content span.enum, .content a.enum, .block a.current.enum { color: #AD378A; }
+.content span.struct, .content a.struct, .block a.current.struct { color: #AD378A; }
+.content span.type, .content a.type, .block a.current.type { color:  #AD378A; }
+.content span.foreigntype, .content a.foreigntype, .block a.current.foreigntype { color: #3873AD; }
+.content span.associatedtype,
+.content a.associatedtype,
+.block a.current.associatedtype { color: #3873AD; }
+.content span.attr, .content a.attr, .block a.current.attr,
+.content span.derive, .content a.derive, .block a.current.derive,
+.content span.macro, .content a.macro, .block a.current.macro { color: #068000; }
+.content span.union, .content a.union, .block a.current.union { color: #AD378A; }
+.content span.constant, .content a.constant, .block a.current.constant,
+.content span.static, .content a.static, .block a.current.static { color: #3873AD; }
+.content span.primitive, .content a.primitive, .block a.current.primitive { color: #AD378A; }
+.content span.externcrate,
+.content span.mod, .content a.mod, .block a.current.mod { color: #3873AD; }
+.content span.trait, .content a.trait, .block a.current.trait { color: #6E4FC9; }
+.content span.traitalias, .content a.traitalias, .block a.current.traitalias { color: #5137AD; }
+.content span.fn, .content a.fn, .block a.current.fn,
+.content span.method, .content a.method, .block a.current.method,
+.content span.tymethod, .content a.tymethod, .block a.current.tymethod,
+.content .fnname { color: #AD7C37; }
+.content span.keyword, .content a.keyword, .block a.current.keyword { color: #3873AD; }
+
+.sidebar a { color: #356da4; }
+.sidebar a.current.enum { color: #a63283; }
+.sidebar a.current.struct { color: #a63283; }
+.sidebar a.current.type { color: #a63283; }
+.sidebar a.current.associatedtype { color: #356da4; }
+.sidebar a.current.foreigntype { color: #356da4; }
+.sidebar a.current.attr,
+.sidebar a.current.derive,
+.sidebar a.current.macro { color: #067901; }
+.sidebar a.current.union { color: #a63283; }
+.sidebar a.current.constant
+.sidebar a.current.static { color: #356da4; }
+.sidebar a.current.primitive { color: #a63283; }
+.sidebar a.current.externcrate
+.sidebar a.current.mod { color: #356da4; }
+.sidebar a.current.trait { color: #6849c3; }
+.sidebar a.current.traitalias { color: #4b349e; }
+.sidebar a.current.fn,
+.sidebar a.current.method,
+.sidebar a.current.tymethod { color: #a67736; }
+.sidebar a.current.keyword { color: #356da4; }
+
+nav.main .current {
+	border-top-color: #000;
+	border-bottom-color: #000;
+}
+nav.main .separator {
+	border: 1px solid #000;
+}
+
+a {
+	color: #3873AD;
+}
+
+body.source .example-wrap pre.rust a {
+	background: #eee;
+}
+
+details.rustdoc-toggle > summary.hideme > span,
+details.rustdoc-toggle > summary::before {
+	color: #999;
+}
+
+#crate-search, .search-input {
+	background-color: white;
+	border-color: #e0e0e0;
+}
+
+#crate-search {
+	/* Without the `!important`, the border-color is ignored for `<select>`...
+	   It cannot be in the group above because `.search-input` has a different border color on
+	   hover. */
+	border-color: #e0e0e0 !important;
+}
+
+.search-input:focus {
+	border-color: #66afe9;
+}
+
+.stab.empty-impl { background: #FFF5D6; border-color: #FFC600; }
+.stab.unstable { background: #FFF5D6; border-color: #FFC600; }
+.stab.deprecated { background: #ffc4c4; border-color: #db7b7b; }
+.stab.must_implement { background: #F3DFFF; border-color: #b07bdb; }
+.stab.portability { background: #F3DFFF; border-color: #b07bdb; }
+.stab.portability > code { background: none; }
+
+.rightside,
+.out-of-band {
+	color: grey;
+}
+
+.line-numbers :target { background-color: transparent; }
+
+/* Code highlighting */
+pre.rust .kw { color: #8959A8; }
+pre.rust .kw-2, pre.rust .prelude-ty { color: #4271AE; }
+pre.rust .number, pre.rust .string { color: #718C00; }
+pre.rust .self, pre.rust .bool-val, pre.rust .prelude-val,
+pre.rust .attribute, pre.rust .attribute .ident { color: #C82829; }
+pre.rust .comment { color: #8E908C; }
+pre.rust .doccomment { color: #4D4D4C; }
+pre.rust .macro, pre.rust .macro-nonterminal { color: #3E999F; }
+pre.rust .lifetime { color: #B76514; }
+pre.rust .question-mark {
+	color: #ff9011;
+}
+
+.example-wrap > pre.line-number {
+	border-color: #c7c7c7;
+}
+
+a.test-arrow {
+	color: #f5f5f5;
+	background-color: rgba(78, 139, 202, 0.2);
+}
+
+a.test-arrow:hover{
+	background-color: #4e8bca;
+}
+
+.toggle-label,
+.code-attribute {
+	color: #999;
+}
+
+:target {
+	background: #FDFFD3;
+	border-right: 3px solid #AD7C37;
+}
+
+pre.compile_fail {
+	border-left: 2px solid rgba(255,0,0,.5);
+}
+
+pre.compile_fail:hover, .information:hover + pre.compile_fail {
+	border-left: 2px solid #f00;
+}
+
+pre.should_panic {
+	border-left: 2px solid rgba(255,0,0,.5);
+}
+
+pre.should_panic:hover, .information:hover + pre.should_panic {
+	border-left: 2px solid #f00;
+}
+
+pre.ignore {
+	border-left: 2px solid rgba(255,142,0,.6);
+}
+
+pre.ignore:hover, .information:hover + pre.ignore {
+	border-left: 2px solid #ff9200;
+}
+
+.tooltip.compile_fail {
+	color: rgba(255,0,0,.5);
+}
+
+.information > .compile_fail:hover {
+	color: #f00;
+}
+
+.tooltip.should_panic {
+	color: rgba(255,0,0,.5);
+}
+
+.information > .should_panic:hover {
+	color: #f00;
+}
+
+.tooltip.ignore {
+	color: rgba(255,142,0,.6);
+}
+
+.information > .ignore:hover {
+	color: #ff9200;
+}
+
+.search-failed a {
+	color: #3873AD;
+}
+
+.tooltip::after {
+	background-color: #000;
+	color: #fff;
+}
+
+.tooltip::before {
+	border-color: transparent black transparent transparent;
+}
+
+.notable-traits-tooltiptext {
+	background-color: #eee;
+	border-color: #999;
+}
+
+.notable-traits-tooltiptext .notable {
+	border-bottom-color: #DDDDDD;
+}
+
+#titles > button:not(.selected) {
+	background-color: #e6e6e6;
+	border-top-color: #e6e6e6;
+}
+
+#titles > button:hover, #titles > button.selected {
+	background-color: #ffffff;
+	border-top-color: #0089ff;
+}
+
+#titles > button > div.count {
+	color: #888;
+}
+
+@media (max-width: 700px) {
+	.sidebar-elems {
+		border-right-color: #000;
+	}
+}
+
+kbd {
+	color: #000;
+	background-color: #fafbfc;
+	border-color: #d1d5da;
+	border-bottom-color: #c6cbd1;
+	box-shadow: inset 0 -1px 0 #c6cbd1;
+}
+
+#settings-menu > a, #help-button > button {
+	border-color: #e0e0e0;
+	background-color: #fff;
+}
+
+#settings-menu > a:hover, #settings-menu > a:focus,
+#help-button > button:hover, #help-button > button:focus {
+	border-color: #717171;
+}
+
+.popover, .popover::before,
+#help-button span.top, #help-button span.bottom {
+	border-color: #DDDDDD;
+}
+
+#copy-path {
+	color: #999;
+}
+#copy-path > img {
+	filter: invert(50%);
+}
+#copy-path:hover > img {
+	filter: invert(35%);
+}
+
+#theme-choices {
+	border-color: #ccc;
+	background-color: #fff;
+}
+
+#theme-choices > button:not(:first-child) {
+	border-top-color: #e0e0e0;
+}
+
+#theme-choices > button:hover, #theme-choices > button:focus {
+	background-color: #eee;
+}
+
+.search-results .result-name span.alias {
+	color: #000;
+}
+.search-results .result-name span.grey {
+	color: #999;
+}
+
+#source-sidebar > .title {
+	border-bottom-color: #ccc;
+}
+#source-sidebar div.files > a:hover, details.dir-entry summary:hover,
+#source-sidebar div.files > a:focus, details.dir-entry summary:focus {
+	background-color: #E0E0E0;
+}
+#source-sidebar div.files > a.selected {
+	background-color: #fff;
+}
+.scraped-example-list .scrape-help {
+	border-color: #555;
+	color: #333;
+}
+.scraped-example-list .scrape-help:hover {
+	border-color: black;
+	color: black;
+}
+.more-examples-toggle summary, .more-examples-toggle .hide-more {
+	color: #999;
+}
+.scraped-example .example-wrap .rust span.highlight {
+	background: #fcffd6;
+}
+.scraped-example .example-wrap .rust span.highlight.focus {
+	background: #f6fdb0;
+}
+.scraped-example:not(.expanded) .code-wrapper:before {
+	background: linear-gradient(to bottom, rgba(255, 255, 255, 1), rgba(255, 255, 255, 0));
+}
+.scraped-example:not(.expanded) .code-wrapper:after {
+	background: linear-gradient(to top, rgba(255, 255, 255, 1), rgba(255, 255, 255, 0));
+}
+.toggle-line-inner {
+	background: #ccc;
+}
+.toggle-line:hover .toggle-line-inner {
+	background: #999;
+}
diff --git a/src/librustdoc/html/static/fonts/FiraSans-LICENSE.txt b/src/librustdoc/html/static/fonts/FiraSans-LICENSE.txt
new file mode 100644
index 000000000..ff9afab06
--- /dev/null
+++ b/src/librustdoc/html/static/fonts/FiraSans-LICENSE.txt
@@ -0,0 +1,94 @@
+Digitized data copyright (c) 2012-2015, The Mozilla Foundation and Telefonica S.A.
+with Reserved Font Name < Fira >,
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.
diff --git a/src/librustdoc/html/static/fonts/FiraSans-Medium.woff2 b/src/librustdoc/html/static/fonts/FiraSans-Medium.woff2
new file mode 100644
index 000000000..7a1e5fc54
--- /dev/null
+++ b/src/librustdoc/html/static/fonts/FiraSans-Medium.woff2
diff --git a/src/librustdoc/html/static/fonts/FiraSans-Regular.woff2 b/src/librustdoc/html/static/fonts/FiraSans-Regular.woff2
new file mode 100644
index 000000000..e766e06cc
--- /dev/null
+++ b/src/librustdoc/html/static/fonts/FiraSans-Regular.woff2
diff --git a/src/librustdoc/html/static/fonts/NanumBarunGothic-LICENSE.txt b/src/librustdoc/html/static/fonts/NanumBarunGothic-LICENSE.txt
new file mode 100644
index 000000000..0bf46682b
--- /dev/null
+++ b/src/librustdoc/html/static/fonts/NanumBarunGothic-LICENSE.txt
@@ -0,0 +1,99 @@
+Copyright (c) 2010, NAVER Corporation (https://www.navercorp.com/),
+
+with Reserved Font Name Nanum, Naver Nanum, NanumGothic, Naver NanumGothic,
+NanumMyeongjo, Naver NanumMyeongjo, NanumBrush, Naver NanumBrush, NanumPen,
+Naver NanumPen, Naver NanumGothicEco, NanumGothicEco, Naver NanumMyeongjoEco,
+NanumMyeongjoEco, Naver NanumGothicLight, NanumGothicLight, NanumBarunGothic,
+Naver NanumBarunGothic, NanumSquareRound, NanumBarunPen, MaruBuri
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.
diff --git a/src/librustdoc/html/static/fonts/NanumBarunGothic.ttf.woff2 b/src/librustdoc/html/static/fonts/NanumBarunGothic.ttf.woff2
new file mode 100644
index 000000000..1866ad4bc
--- /dev/null
+++ b/src/librustdoc/html/static/fonts/NanumBarunGothic.ttf.woff2
diff --git a/src/librustdoc/html/static/fonts/SourceCodePro-It.ttf.woff2 b/src/librustdoc/html/static/fonts/SourceCodePro-It.ttf.woff2
new file mode 100644
index 000000000..462c34efc
--- /dev/null
+++ b/src/librustdoc/html/static/fonts/SourceCodePro-It.ttf.woff2
diff --git a/src/librustdoc/html/static/fonts/SourceCodePro-LICENSE.txt b/src/librustdoc/html/static/fonts/SourceCodePro-LICENSE.txt
new file mode 100644
index 000000000..07542572e
--- /dev/null
+++ b/src/librustdoc/html/static/fonts/SourceCodePro-LICENSE.txt
@@ -0,0 +1,93 @@
+Copyright 2010, 2012 Adobe Systems Incorporated (http://www.adobe.com/), with Reserved Font Name 'Source'. All Rights Reserved. Source is a trademark of Adobe Systems Incorporated in the United States and/or other countries.
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+
+This license is copied below, and is also available with a FAQ at: http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.
diff --git a/src/librustdoc/html/static/fonts/SourceCodePro-Regular.ttf.woff2 b/src/librustdoc/html/static/fonts/SourceCodePro-Regular.ttf.woff2
new file mode 100644
index 000000000..10b558e0b
--- /dev/null
+++ b/src/librustdoc/html/static/fonts/SourceCodePro-Regular.ttf.woff2
diff --git a/src/librustdoc/html/static/fonts/SourceCodePro-Semibold.ttf.woff2 b/src/librustdoc/html/static/fonts/SourceCodePro-Semibold.ttf.woff2
new file mode 100644
index 000000000..5ec64eef0
--- /dev/null
+++ b/src/librustdoc/html/static/fonts/SourceCodePro-Semibold.ttf.woff2
diff --git a/src/librustdoc/html/static/fonts/SourceSerif4-Bold.ttf.woff2 b/src/librustdoc/html/static/fonts/SourceSerif4-Bold.ttf.woff2
new file mode 100644
index 000000000..db57d2145
--- /dev/null
+++ b/src/librustdoc/html/static/fonts/SourceSerif4-Bold.ttf.woff2
diff --git a/src/librustdoc/html/static/fonts/SourceSerif4-It.ttf.woff2 b/src/librustdoc/html/static/fonts/SourceSerif4-It.ttf.woff2
new file mode 100644
index 000000000..1cbc021a3
--- /dev/null
+++ b/src/librustdoc/html/static/fonts/SourceSerif4-It.ttf.woff2
diff --git a/src/librustdoc/html/static/fonts/SourceSerif4-LICENSE.md b/src/librustdoc/html/static/fonts/SourceSerif4-LICENSE.md
new file mode 100644
index 000000000..68ea18924
--- /dev/null
+++ b/src/librustdoc/html/static/fonts/SourceSerif4-LICENSE.md
@@ -0,0 +1,93 @@
+Copyright 2014-2021 Adobe (http://www.adobe.com/), with Reserved Font Name 'Source'. All Rights Reserved. Source is a trademark of Adobe in the United States and/or other countries.
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+
+This license is copied below, and is also available with a FAQ at: http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.
diff --git a/src/librustdoc/html/static/fonts/SourceSerif4-Regular.ttf.woff2 b/src/librustdoc/html/static/fonts/SourceSerif4-Regular.ttf.woff2
new file mode 100644
index 000000000..2db73fe2b
--- /dev/null
+++ b/src/librustdoc/html/static/fonts/SourceSerif4-Regular.ttf.woff2
diff --git a/src/librustdoc/html/static/images/clipboard.svg b/src/librustdoc/html/static/images/clipboard.svg
new file mode 100644
index 000000000..8adbd9963
--- /dev/null
+++ b/src/librustdoc/html/static/images/clipboard.svg
@@ -0,0 +1 @@
+<svg width="24" height="25" viewBox="0 0 24 25" xmlns="http://www.w3.org/2000/svg" aria-label="Copy to clipboard"><path d="M18 20h2v3c0 1-1 2-2 2H2c-.998 0-2-1-2-2V5c0-.911.755-1.667 1.667-1.667h5A3.323 3.323 0 0110 0a3.323 3.323 0 013.333 3.333h5C19.245 3.333 20 4.09 20 5v8.333h-2V9H2v14h16v-3zM3 7h14c0-.911-.793-1.667-1.75-1.667H13.5c-.957 0-1.75-.755-1.75-1.666C11.75 2.755 10.957 2 10 2s-1.75.755-1.75 1.667c0 .911-.793 1.666-1.75 1.666H4.75C3.793 5.333 3 6.09 3 7z"/><path d="M4 19h6v2H4zM12 11H4v2h8zM4 17h4v-2H4zM15 15v-3l-4.5 4.5L15 21v-3l8.027-.032L23 15z"/></svg>
diff --git a/src/librustdoc/html/static/images/down-arrow.svg b/src/librustdoc/html/static/images/down-arrow.svg
new file mode 100644
index 000000000..35437e77a
--- /dev/null
+++ b/src/librustdoc/html/static/images/down-arrow.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" id="Layer_1" width="128" height="128" enable-background="new 0 0 128 128" version="1.1" viewBox="-30 -20 176 176" xml:space="preserve"><g><line x1="111" x2="64" y1="40.5" y2="87.499" fill="none" stroke="#2F3435" stroke-linecap="square" stroke-miterlimit="10" stroke-width="12"/><line x1="64" x2="17" y1="87.499" y2="40.5" fill="none" stroke="#2F3435" stroke-linecap="square" stroke-miterlimit="10" stroke-width="12"/></g></svg>
\ No newline at end of file
diff --git a/src/librustdoc/html/static/images/favicon-16x16.png b/src/librustdoc/html/static/images/favicon-16x16.png
new file mode 100644
index 000000000..ea4b45cae
--- /dev/null
+++ b/src/librustdoc/html/static/images/favicon-16x16.png
diff --git a/src/librustdoc/html/static/images/favicon-32x32.png b/src/librustdoc/html/static/images/favicon-32x32.png
new file mode 100644
index 000000000..69b8613ce
--- /dev/null
+++ b/src/librustdoc/html/static/images/favicon-32x32.png
diff --git a/src/librustdoc/html/static/images/favicon.svg b/src/librustdoc/html/static/images/favicon.svg
new file mode 100644
index 000000000..8b34b5119
--- /dev/null
+++ b/src/librustdoc/html/static/images/favicon.svg
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?><!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd"><svg width="100%" height="100%" viewBox="0 0 32 32" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xml:space="preserve" xmlns:serif="http://www.serif.com/" style="fill-rule:evenodd;clip-rule:evenodd;stroke-linecap:round;stroke-linejoin:round;">
+<defs>
+  <style type="text/css"><![CDATA[
+    #logo {
+      fill-rule: nonzero;
+    }
+    #logo-teeth {
+      stroke: #000000;
+      stroke-width: 0.92px;
+    }
+    @media (prefers-color-scheme: dark) {
+      #logo {
+        fill: #FFFFFF;
+        fill-rule: nonzero;
+      }
+      #logo-teeth {
+        fill: #FFFFFF;
+        stroke: #FFFFFF;
+        stroke-width: 0.92px;
+      }
+    }
+  ]]></style>
+</defs>
+<path id="logo" d="M15.993,1.54c-7.972,0 -14.461,6.492 -14.461,14.462c0,7.969 6.492,14.461 14.461,14.461c7.97,0 14.462,-6.492 14.462,-14.461c0,-7.97 -6.492,-14.462 -14.462,-14.462Zm-0.021,1.285c0.511,0.013 0.924,0.439 0.924,0.951c0,0.522 -0.43,0.952 -0.952,0.952c-0.522,0 -0.951,-0.43 -0.951,-0.952c0,0 0,0 0,0c0,-0.522 0.429,-0.952 0.951,-0.952c0.01,0 0.019,0.001 0.028,0.001Zm2.178,1.566c3.379,0.633 6.313,2.723 8.016,5.709l-1.123,2.533c-0.193,0.438 0.006,0.952 0.44,1.147l2.16,0.958c0.067,0.675 0.076,1.355 0.025,2.031l-1.202,0c-0.12,0 -0.169,0.08 -0.169,0.196l0,0.551c0,1.297 -0.731,1.582 -1.373,1.652c-0.612,0.07 -1.288,-0.257 -1.374,-0.63c-0.361,-2.029 -0.961,-2.46 -1.909,-3.21c1.178,-0.746 2.401,-1.85 2.401,-3.325c0,-1.594 -1.092,-2.597 -1.835,-3.09c-1.046,-0.688 -2.203,-0.826 -2.515,-0.826l-12.421,0c1.717,-1.918 4.02,-3.218 6.55,-3.696l1.466,1.536c0.33,0.346 0.878,0.361 1.223,0.028l1.64,-1.564Zm-13.522,7.043c0.511,0.015 0.924,0.44 0.924,0.951c0,0.522 -0.43,0.952 -0.952,0.952c-0.522,0 -0.951,-0.43 -0.951,-0.952c0,0 0,0 0,0c0,-0.522 0.429,-0.951 0.951,-0.951c0.009,0 0.019,0 0.028,0Zm22.685,0.043c0.511,0.015 0.924,0.44 0.924,0.951c0,0.522 -0.43,0.952 -0.952,0.952c-0.522,0 -0.951,-0.43 -0.951,-0.952c0,0 0,0 0,0c0,-0.522 0.429,-0.952 0.951,-0.952c0.01,0 0.019,0 0.028,0.001Zm-20.892,0.153l1.658,0l0,7.477l-3.347,0c-0.414,-1.452 -0.542,-2.97 -0.38,-4.47l2.05,-0.912c0.438,-0.195 0.637,-0.706 0.441,-1.144l-0.422,-0.951Zm6.92,0.079l3.949,0c0.205,0 1.441,0.236 1.441,1.163c0,0.768 -0.948,1.043 -1.728,1.043l-3.665,0l0.003,-2.206Zm0,5.373l3.026,0c0.275,0 1.477,0.079 1.86,1.615c0.119,0.471 0.385,2.007 0.566,2.499c0.18,0.551 0.911,1.652 1.691,1.652l4.938,0c-0.331,0.444 -0.693,0.863 -1.083,1.255l-2.01,-0.432c-0.468,-0.101 -0.93,0.199 -1.031,0.667l-0.477,2.228c-3.104,1.406 -6.672,1.389 -9.762,-0.046l-0.478,-2.228c-0.101,-0.468 -0.56,-0.767 -1.028,-0.667l-1.967,0.423c-0.365,-0.377 -0.704,-0.778 -1.016,-1.2l9.567,0c0.107,0 0.181,-0.018 0.181,-0.119l0,-3.384c0,-0.097 -0.074,-0.119 -0.181,-0.119l-2.799,0l0.003,-2.144Zm-4.415,7.749c0.512,0.015 0.924,0.44 0.924,0.951c0,0.522 -0.429,0.952 -0.951,0.952c-0.522,0 -0.952,-0.43 -0.952,-0.952c0,0 0,0 0,0c0,-0.522 0.43,-0.952 0.952,-0.952c0.009,0 0.018,0.001 0.027,0.001Zm14.089,0.043c0.511,0.015 0.924,0.439 0.923,0.951c0,0.522 -0.429,0.952 -0.951,0.952c-0.522,0 -0.951,-0.43 -0.951,-0.952c0,0 0,0 0,0c0,-0.522 0.429,-0.952 0.951,-0.952c0.009,0 0.018,0 0.028,0.001Z"/><path id="logo-teeth" d="M29.647,16.002c0,7.49 -6.163,13.653 -13.654,13.653c-7.49,0 -13.654,-6.163 -13.654,-13.653c0,-7.491 6.164,-13.654 13.654,-13.654c7.491,0 13.654,6.163 13.654,13.654Zm-0.257,-1.319l2.13,1.319l-2.13,1.318l1.83,1.71l-2.344,0.878l1.463,2.035l-2.475,0.404l1.04,2.282l-2.506,-0.089l0.575,2.442l-2.441,-0.576l0.089,2.506l-2.283,-1.04l-0.403,2.475l-2.035,-1.462l-0.878,2.343l-1.71,-1.829l-1.319,2.129l-1.318,-2.129l-1.71,1.829l-0.878,-2.343l-2.035,1.462l-0.404,-2.475l-2.282,1.04l0.089,-2.506l-2.442,0.576l0.575,-2.442l-2.505,0.089l1.04,-2.282l-2.475,-0.404l1.462,-2.035l-2.343,-0.878l1.829,-1.71l-2.129,-1.318l2.129,-1.319l-1.829,-1.71l2.343,-0.878l-1.462,-2.035l2.475,-0.404l-1.04,-2.282l2.505,0.089l-0.575,-2.441l2.442,0.575l-0.089,-2.506l2.282,1.04l0.404,-2.475l2.035,1.463l0.878,-2.344l1.71,1.83l1.318,-2.13l1.319,2.13l1.71,-1.83l0.878,2.344l2.035,-1.463l0.403,2.475l2.283,-1.04l-0.089,2.506l2.441,-0.575l-0.575,2.441l2.506,-0.089l-1.04,2.282l2.475,0.404l-1.463,2.035l2.344,0.878l-1.83,1.71Z"/></svg>
diff --git a/src/librustdoc/html/static/images/rust-logo.svg b/src/librustdoc/html/static/images/rust-logo.svg
new file mode 100644
index 000000000..62424d8ff
--- /dev/null
+++ b/src/librustdoc/html/static/images/rust-logo.svg
@@ -0,0 +1,61 @@
+<svg version="1.1" height="106" width="106" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+<g id="logo" transform="translate(53, 53)">
+  <path id="r" transform="translate(0.5, 0.5)" stroke="black" stroke-width="1" stroke-linejoin="round" d="
+    M -9,-15 H 4 C 12,-15 12,-7 4,-7 H -9 Z
+    M -40,22 H 0 V 11 H -9 V 3 H 1 C 12,3 6,22 15,22 H 40
+    V 3 H 34 V 5 C 34,13 25,12 24,7 C 23,2 19,-2 18,-2 C 33,-10 24,-26 12,-26 H -35
+    V -15 H -25 V 11 H -40 Z" />
+  <g id="gear" mask="url(#holes)">
+    <circle r="43" fill="none" stroke="black" stroke-width="9" />
+    <g id="cogs">
+      <polygon id="cog" stroke="black" stroke-width="3" stroke-linejoin="round" points="46,3 51,0 46,-3" />
+      <use xlink:href="#cog" transform="rotate(11.25)" />
+      <use xlink:href="#cog" transform="rotate(22.50)" />
+      <use xlink:href="#cog" transform="rotate(33.75)" />
+      <use xlink:href="#cog" transform="rotate(45.00)" />
+      <use xlink:href="#cog" transform="rotate(56.25)" />
+      <use xlink:href="#cog" transform="rotate(67.50)" />
+      <use xlink:href="#cog" transform="rotate(78.75)" />
+      <use xlink:href="#cog" transform="rotate(90.00)" />
+      <use xlink:href="#cog" transform="rotate(101.25)" />
+      <use xlink:href="#cog" transform="rotate(112.50)" />
+      <use xlink:href="#cog" transform="rotate(123.75)" />
+      <use xlink:href="#cog" transform="rotate(135.00)" />
+      <use xlink:href="#cog" transform="rotate(146.25)" />
+      <use xlink:href="#cog" transform="rotate(157.50)" />
+      <use xlink:href="#cog" transform="rotate(168.75)" />
+      <use xlink:href="#cog" transform="rotate(180.00)" />
+      <use xlink:href="#cog" transform="rotate(191.25)" />
+      <use xlink:href="#cog" transform="rotate(202.50)" />
+      <use xlink:href="#cog" transform="rotate(213.75)" />
+      <use xlink:href="#cog" transform="rotate(225.00)" />
+      <use xlink:href="#cog" transform="rotate(236.25)" />
+      <use xlink:href="#cog" transform="rotate(247.50)" />
+      <use xlink:href="#cog" transform="rotate(258.75)" />
+      <use xlink:href="#cog" transform="rotate(270.00)" />
+      <use xlink:href="#cog" transform="rotate(281.25)" />
+      <use xlink:href="#cog" transform="rotate(292.50)" />
+      <use xlink:href="#cog" transform="rotate(303.75)" />
+      <use xlink:href="#cog" transform="rotate(315.00)" />
+      <use xlink:href="#cog" transform="rotate(326.25)" />
+      <use xlink:href="#cog" transform="rotate(337.50)" />
+      <use xlink:href="#cog" transform="rotate(348.75)" />
+    </g>
+    <g id="mounts">
+      <polygon id="mount" stroke="black" stroke-width="6" stroke-linejoin="round" points="-7,-42 0,-35 7,-42" />
+      <use xlink:href="#mount" transform="rotate(72)" />
+      <use xlink:href="#mount" transform="rotate(144)" />
+      <use xlink:href="#mount" transform="rotate(216)" />
+      <use xlink:href="#mount" transform="rotate(288)" />
+    </g>
+  </g>
+  <mask id="holes">
+    <rect x="-60" y="-60" width="120" height="120" fill="white"/>
+    <circle id="hole" cy="-40" r="3" />
+    <use xlink:href="#hole" transform="rotate(72)" />
+    <use xlink:href="#hole" transform="rotate(144)" />
+    <use xlink:href="#hole" transform="rotate(216)" />
+    <use xlink:href="#hole" transform="rotate(288)" />
+  </mask>
+</g>
+</svg>
diff --git a/src/librustdoc/html/static/images/toggle-minus.svg b/src/librustdoc/html/static/images/toggle-minus.svg
new file mode 100644
index 000000000..73154788a
--- /dev/null
+++ b/src/librustdoc/html/static/images/toggle-minus.svg
@@ -0,0 +1 @@
+<svg width="17" height="17" shape-rendering="crispEdges" stroke="#000" fill="none" xmlns="http://www.w3.org/2000/svg"><path d="M5 2.5H2.5v12H5m7-12h2.5v12H12M5 8.5h7"/></svg>
\ No newline at end of file
diff --git a/src/librustdoc/html/static/images/toggle-plus.svg b/src/librustdoc/html/static/images/toggle-plus.svg
new file mode 100644
index 000000000..08b17033e
--- /dev/null
+++ b/src/librustdoc/html/static/images/toggle-plus.svg
@@ -0,0 +1 @@
+<svg width="17" height="17" shape-rendering="crispEdges" stroke="#000" fill="none" xmlns="http://www.w3.org/2000/svg"><path d="M5 2.5H2.5v12H5m7-12h2.5v12H12M5 8.5h7M8.5 12V8.625v0V5"/></svg>
\ No newline at end of file
diff --git a/src/librustdoc/html/static/images/wheel.svg b/src/librustdoc/html/static/images/wheel.svg
new file mode 100644
index 000000000..01da3b24c
--- /dev/null
+++ b/src/librustdoc/html/static/images/wheel.svg
@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" id="Capa_1" width="27.434" height="29.5" enable-background="new 0 0 27.434 29.5" version="1.1" viewBox="0 0 27.434 29.5" xml:space="preserve"><g><path d="M27.315,18.389c-0.165-0.604-0.509-1.113-0.981-1.459c-0.042-0.144-0.083-0.429-0.015-0.761l0.037-0.177v-0.182V14.8 c0-1.247-0.006-1.277-0.048-1.472c-0.076-0.354-0.035-0.653,0.007-0.803c0.477-0.346,0.828-0.861,0.996-1.476 c0.261-0.956,0.076-2.091-0.508-3.114l-0.591-1.032c-0.746-1.307-1.965-2.119-3.182-2.119c-0.378,0-0.75,0.081-1.085,0.235 c-0.198-0.025-0.554-0.15-0.855-0.389l-0.103-0.082l-0.114-0.065l-1.857-1.067L18.92,3.36l-0.105-0.044 c-0.376-0.154-0.658-0.41-0.768-0.556C17.918,1.172,16.349,0,14.296,0H13.14c-2.043,0-3.608,1.154-3.749,2.721 C9.277,2.862,8.999,3.104,8.633,3.25l-0.1,0.039L8.439,3.341L6.495,4.406L6.363,4.479L6.245,4.573 C5.936,4.82,5.596,4.944,5.416,4.977c-0.314-0.139-0.66-0.21-1.011-0.21c-1.198,0-2.411,0.819-3.165,2.139L0.65,7.938 c-0.412,0.72-0.642,1.521-0.644,2.258c-0.003,0.952,0.362,1.756,1.013,2.256c0.034,0.155,0.061,0.448-0.016,0.786 c-0.038,0.168-0.062,0.28-0.062,1.563c0,1.148,0,1.148,0.015,1.262l0.009,0.073l0.017,0.073c0.073,0.346,0.045,0.643,0.011,0.802 C0.348,17.512-0.01,18.314,0,19.268c0.008,0.729,0.238,1.523,0.648,2.242l0.589,1.031c0.761,1.331,1.967,2.159,3.15,2.159 c0.324,0,0.645-0.064,0.938-0.187c0.167,0.038,0.492,0.156,0.813,0.416l0.11,0.088l0.124,0.07l2.045,1.156l0.102,0.057l0.107,0.043 c0.364,0.147,0.646,0.381,0.766,0.521c0.164,1.52,1.719,2.634,3.745,2.634h1.155c2.037,0,3.598-1.134,3.747-2.675 c0.117-0.145,0.401-0.393,0.774-0.549l0.111-0.047l0.105-0.062l1.96-1.159l0.105-0.062l0.097-0.075 c0.309-0.246,0.651-0.371,0.832-0.402c0.313,0.138,0.662,0.212,1.016,0.212c1.199,0,2.412-0.82,3.166-2.139l0.59-1.032 C27.387,20.48,27.575,19.342,27.315,18.389z M25.274,20.635l-0.59,1.032c-0.438,0.765-1.104,1.251-1.639,1.251 c-0.133,0-0.258-0.029-0.369-0.094c-0.15-0.086-0.346-0.127-0.566-0.127c-0.596,0-1.383,0.295-2.01,0.796l-1.96,1.157 c-1.016,0.425-1.846,1.291-1.846,1.929s-0.898,1.159-1.998,1.159H13.14c-1.1,0-1.998-0.514-1.998-1.141s-0.834-1.477-1.854-1.888 l-2.046-1.157c-0.636-0.511-1.425-0.814-2.006-0.814c-0.202,0-0.379,0.037-0.516,0.115c-0.101,0.057-0.214,0.084-0.333,0.084 c-0.518,0-1.179-0.498-1.62-1.271l-0.591-1.032c-0.545-0.954-0.556-1.983-0.024-2.286c0.532-0.305,0.78-1.432,0.551-2.506 c0,0,0-0.003,0-1.042c0-1.088,0.021-1.18,0.021-1.18c0.238-1.072-0.01-2.203-0.552-2.513C1.631,10.8,1.634,9.765,2.18,8.812 L2.769,7.78c0.438-0.766,1.103-1.251,1.636-1.251c0.131,0,0.255,0.029,0.365,0.092C4.92,6.707,5.114,6.747,5.334,6.747 c0.596,0,1.38-0.296,2.007-0.795l1.944-1.065c1.021-0.407,1.856-1.277,1.856-1.933c0-0.656,0.898-1.192,1.998-1.192h1.156V1.761 c1.1,0,1.998,0.545,1.998,1.211c0,0.667,0.832,1.554,1.849,1.973L20,6.013c0.618,0.489,1.401,0.775,2.012,0.775 c0.24,0,0.454-0.045,0.62-0.139c0.122-0.069,0.259-0.102,0.403-0.102c0.551,0,1.221,0.476,1.653,1.231l0.59,1.032 c0.544,0.953,0.518,2.004-0.062,2.334c-0.577,0.331-0.859,1.48-0.627,2.554c0,0,0.01,0.042,0.01,1.103c0,1.012,0,1.012,0,1.012 c-0.218,1.049,0.068,2.174,0.636,2.498C25.802,18.635,25.819,19.68,25.274,20.635z"/><path d="M13.61,7.611c-3.913,0-7.084,3.173-7.084,7.085c0,3.914,3.171,7.085,7.084,7.085s7.085-3.172,7.085-7.085 C20.695,10.784,17.523,7.611,13.61,7.611z M13.61,20.02c-2.936,0-5.323-2.388-5.323-5.323c0-2.935,2.388-5.323,5.323-5.323 s5.324,2.388,5.324,5.323C18.934,17.632,16.546,20.02,13.61,20.02z"/><path d="M13.682,9.908c-2.602,0-4.718,2.116-4.718,4.718c0,2.601,2.116,4.716,4.718,4.716c2.601,0,4.717-2.115,4.717-4.716 C18.399,12.024,16.283,9.908,13.682,9.908z M13.682,17.581c-1.633,0-2.956-1.323-2.956-2.955s1.323-2.956,2.956-2.956 c1.632,0,2.956,1.324,2.956,2.956S15.314,17.581,13.682,17.581z"/></g></svg>
\ No newline at end of file
diff --git a/src/librustdoc/html/static/js/README.md b/src/librustdoc/html/static/js/README.md
new file mode 100644
index 000000000..1fd859ad7
--- /dev/null
+++ b/src/librustdoc/html/static/js/README.md
@@ -0,0 +1,15 @@
+# Rustdoc JS
+
+These JavaScript files are incorporated into the rustdoc binary at build time,
+and are minified and written to the filesystem as part of the doc build process.
+
+We use the [Closure Compiler](https://github.com/google/closure-compiler/wiki/Annotating-JavaScript-for-the-Closure-Compiler)
+dialect of JSDoc to comment our code and annotate params and return types.
+To run a check:
+
+    ./x.py doc library/std
+    npm i -g google-closure-compiler
+    google-closure-compiler -W VERBOSE \
+      build/<YOUR PLATFORM>/doc/{search-index*.js,crates*.js} \
+      src/librustdoc/html/static/js/{search.js,main.js,storage.js} \
+      --externs src/librustdoc/html/static/js/externs.js >/dev/null
diff --git a/src/librustdoc/html/static/js/externs.js b/src/librustdoc/html/static/js/externs.js
new file mode 100644
index 000000000..ecbe15a59
--- /dev/null
+++ b/src/librustdoc/html/static/js/externs.js
@@ -0,0 +1,142 @@
+// This file contains type definitions that are processed by the Closure Compiler but are
+// not put into the JavaScript we include as part of the documentation. It is used for
+// type checking. See README.md in this directory for more info.
+
+/* eslint-disable */
+let searchState;
+function initSearch(searchIndex){}
+
+/**
+ * @typedef {{
+ *     name: string,
+ *     fullPath: Array<string>,
+ *     pathWithoutLast: Array<string>,
+ *     pathLast: string,
+ *     generics: Array<QueryElement>,
+ * }}
+ */
+let QueryElement;
+
+/**
+ * @typedef {{
+ *      pos: number,
+ *      totalElems: number,
+ *      typeFilter: (null|string),
+ *      userQuery: string,
+ * }}
+ */
+let ParserState;
+
+/**
+ * @typedef {{
+ *     original: string,
+ *     userQuery: string,
+ *     typeFilter: number,
+ *     elems: Array<QueryElement>,
+ *     args: Array<QueryElement>,
+ *     returned: Array<QueryElement>,
+ *     foundElems: number,
+ * }}
+ */
+let ParsedQuery;
+
+/**
+ * @typedef {{
+ *    crate: string,
+ *    desc: string,
+ *    id: number,
+ *    name: string,
+ *    normalizedName: string,
+ *    parent: (Object|null|undefined),
+ *    path: string,
+ *    ty: (Number|null|number),
+ *    type: (Array<?>|null)
+ * }}
+ */
+let Row;
+
+/**
+ * @typedef {{
+ *    in_args: Array<Object>,
+ *    returned: Array<Object>,
+ *    others: Array<Object>,
+ *    query: ParsedQuery,
+ * }}
+ */
+let ResultsTable;
+
+/**
+ * @typedef {{
+ *     desc: string,
+ *     displayPath: string,
+ *     fullPath: string,
+ *     href: string,
+ *     id: number,
+ *     lev: number,
+ *     name: string,
+ *     normalizedName: string,
+ *     parent: (Object|undefined),
+ *     path: string,
+ *     ty: number,
+ * }}
+ */
+let Results;
+
+/**
+ * A pair of [inputs, outputs], or 0 for null. This is stored in the search index.
+ * The JavaScript deserializes this into FunctionSearchType.
+ *
+ * Numeric IDs are *ONE-indexed* into the paths array (`p`). Zero is used as a sentinel for `null`
+ * because `null` is four bytes while `0` is one byte.
+ *
+ * An input or output can be encoded as just a number if there is only one of them, AND
+ * it has no generics. The no generics rule exists to avoid ambiguity: imagine if you had
+ * a function with a single output, and that output had a single generic:
+ *
+ *     fn something() -> Result<usize, usize>
+ *
+ * If output was allowed to be any RawFunctionType, it would look like this
+ *
+ *     [[], [50, [3, 3]]]
+ *
+ * The problem is that the above output could be interpreted as either a type with ID 50 and two
+ * generics, or it could be interpreted as a pair of types, the first one with ID 50 and the second
+ * with ID 3 and a single generic parameter that is also ID 3. We avoid this ambiguity by choosing
+ * in favor of the pair of types interpretation. This is why the `(number|Array<RawFunctionType>)`
+ * is used instead of `(RawFunctionType|Array<RawFunctionType>)`.
+ *
+ * @typedef {(
+ *     0 |
+ *     [(number|Array<RawFunctionType>)] |
+ *     [(number|Array<RawFunctionType>), (number|Array<RawFunctionType>)]
+ * )}
+ */
+let RawFunctionSearchType;
+
+/**
+ * A single function input or output type. This is either a single path ID, or a pair of
+ * [path ID, generics].
+ *
+ * Numeric IDs are *ONE-indexed* into the paths array (`p`). Zero is used as a sentinel for `null`
+ * because `null` is four bytes while `0` is one byte.
+ *
+ * @typedef {number | [number, Array<RawFunctionType>]}
+ */
+let RawFunctionType;
+
+/**
+ * @typedef {{
+ *     inputs: Array<FunctionType>,
+ *     outputs: Array<FunctionType>,
+ * }}
+ */
+let FunctionSearchType;
+
+/**
+ * @typedef {{
+ *     name: (null|string),
+ *     ty: (null|number),
+ *     generics: Array<FunctionType>,
+ * }}
+ */
+let FunctionType;
diff --git a/src/librustdoc/html/static/js/main.js b/src/librustdoc/html/static/js/main.js
new file mode 100644
index 000000000..0702b2b0b
--- /dev/null
+++ b/src/librustdoc/html/static/js/main.js
@@ -0,0 +1,974 @@
+// Local js definitions:
+/* global addClass, getSettingValue, hasClass, searchState */
+/* global onEach, onEachLazy, removeClass */
+
+"use strict";
+
+// Get a value from the rustdoc-vars div, which is used to convey data from
+// Rust to the JS. If there is no such element, return null.
+function getVar(name) {
+    const el = document.getElementById("rustdoc-vars");
+    if (el) {
+        return el.attributes["data-" + name].value;
+    } else {
+        return null;
+    }
+}
+
+// Given a basename (e.g. "storage") and an extension (e.g. ".js"), return a URL
+// for a resource under the root-path, with the resource-suffix.
+function resourcePath(basename, extension) {
+    return getVar("root-path") + basename + getVar("resource-suffix") + extension;
+}
+
+function hideMain() {
+    addClass(document.getElementById(MAIN_ID), "hidden");
+}
+
+function showMain() {
+    removeClass(document.getElementById(MAIN_ID), "hidden");
+}
+
+function elemIsInParent(elem, parent) {
+    while (elem && elem !== document.body) {
+        if (elem === parent) {
+            return true;
+        }
+        elem = elem.parentElement;
+    }
+    return false;
+}
+
+function blurHandler(event, parentElem, hideCallback) {
+    if (!elemIsInParent(document.activeElement, parentElem) &&
+        !elemIsInParent(event.relatedTarget, parentElem)
+    ) {
+        hideCallback();
+    }
+}
+
+(function() {
+    window.rootPath = getVar("root-path");
+    window.currentCrate = getVar("current-crate");
+}());
+
+function setMobileTopbar() {
+    // FIXME: It would be nicer to generate this text content directly in HTML,
+    // but with the current code it's hard to get the right information in the right place.
+    const mobileLocationTitle = document.querySelector(".mobile-topbar h2.location");
+    const locationTitle = document.querySelector(".sidebar h2.location");
+    if (mobileLocationTitle && locationTitle) {
+        mobileLocationTitle.innerHTML = locationTitle.innerHTML;
+    }
+}
+
+// Gets the human-readable string for the virtual-key code of the
+// given KeyboardEvent, ev.
+//
+// This function is meant as a polyfill for KeyboardEvent#key,
+// since it is not supported in IE 11 or Chrome for Android. We also test for
+// KeyboardEvent#keyCode because the handleShortcut handler is
+// also registered for the keydown event, because Blink doesn't fire
+// keypress on hitting the Escape key.
+//
+// So I guess you could say things are getting pretty interoperable.
+function getVirtualKey(ev) {
+    if ("key" in ev && typeof ev.key !== "undefined") {
+        return ev.key;
+    }
+
+    const c = ev.charCode || ev.keyCode;
+    if (c === 27) {
+        return "Escape";
+    }
+    return String.fromCharCode(c);
+}
+
+const MAIN_ID = "main-content";
+const SETTINGS_BUTTON_ID = "settings-menu";
+const ALTERNATIVE_DISPLAY_ID = "alternative-display";
+const NOT_DISPLAYED_ID = "not-displayed";
+const HELP_BUTTON_ID = "help-button";
+
+function getSettingsButton() {
+    return document.getElementById(SETTINGS_BUTTON_ID);
+}
+
+function getHelpButton() {
+    return document.getElementById(HELP_BUTTON_ID);
+}
+
+// Returns the current URL without any query parameter or hash.
+function getNakedUrl() {
+    return window.location.href.split("?")[0].split("#")[0];
+}
+
+/**
+ * This function inserts `newNode` after `referenceNode`. It doesn't work if `referenceNode`
+ * doesn't have a parent node.
+ *
+ * @param {HTMLElement} newNode
+ * @param {HTMLElement} referenceNode
+ */
+function insertAfter(newNode, referenceNode) {
+    referenceNode.parentNode.insertBefore(newNode, referenceNode.nextSibling);
+}
+
+/**
+ * This function creates a new `<section>` with the given `id` and `classes` if it doesn't already
+ * exist.
+ *
+ * More information about this in `switchDisplayedElement` documentation.
+ *
+ * @param {string} id
+ * @param {string} classes
+ */
+function getOrCreateSection(id, classes) {
+    let el = document.getElementById(id);
+
+    if (!el) {
+        el = document.createElement("section");
+        el.id = id;
+        el.className = classes;
+        insertAfter(el, document.getElementById(MAIN_ID));
+    }
+    return el;
+}
+
+/**
+ * Returns the `<section>` element which contains the displayed element.
+ *
+ * @return {HTMLElement}
+ */
+function getAlternativeDisplayElem() {
+    return getOrCreateSection(ALTERNATIVE_DISPLAY_ID, "content hidden");
+}
+
+/**
+ * Returns the `<section>` element which contains the not-displayed elements.
+ *
+ * @return {HTMLElement}
+ */
+function getNotDisplayedElem() {
+    return getOrCreateSection(NOT_DISPLAYED_ID, "hidden");
+}
+
+/**
+ * To nicely switch between displayed "extra" elements (such as search results or settings menu)
+ * and to alternate between the displayed and not displayed elements, we hold them in two different
+ * `<section>` elements. They work in pair: one holds the hidden elements while the other
+ * contains the displayed element (there can be only one at the same time!). So basically, we switch
+ * elements between the two `<section>` elements.
+ *
+ * @param {HTMLElement} elemToDisplay
+ */
+function switchDisplayedElement(elemToDisplay) {
+    const el = getAlternativeDisplayElem();
+
+    if (el.children.length > 0) {
+        getNotDisplayedElem().appendChild(el.firstElementChild);
+    }
+    if (elemToDisplay === null) {
+        addClass(el, "hidden");
+        showMain();
+        return;
+    }
+    el.appendChild(elemToDisplay);
+    hideMain();
+    removeClass(el, "hidden");
+}
+
+function browserSupportsHistoryApi() {
+    return window.history && typeof window.history.pushState === "function";
+}
+
+// eslint-disable-next-line no-unused-vars
+function loadCss(cssFileName) {
+    const link = document.createElement("link");
+    link.href = resourcePath(cssFileName, ".css");
+    link.type = "text/css";
+    link.rel = "stylesheet";
+    document.getElementsByTagName("head")[0].appendChild(link);
+}
+
+(function() {
+    function loadScript(url) {
+        const script = document.createElement("script");
+        script.src = url;
+        document.head.append(script);
+    }
+
+    getSettingsButton().onclick = event => {
+        addClass(getSettingsButton(), "rotate");
+        event.preventDefault();
+        // Sending request for the CSS and the JS files at the same time so it will
+        // hopefully be loaded when the JS will generate the settings content.
+        loadCss("settings");
+        loadScript(resourcePath("settings", ".js"));
+    };
+
+    window.searchState = {
+        loadingText: "Loading search results...",
+        input: document.getElementsByClassName("search-input")[0],
+        outputElement: () => {
+            let el = document.getElementById("search");
+            if (!el) {
+                el = document.createElement("section");
+                el.id = "search";
+                getNotDisplayedElem().appendChild(el);
+            }
+            return el;
+        },
+        title: document.title,
+        titleBeforeSearch: document.title,
+        timeout: null,
+        // On the search screen, so you remain on the last tab you opened.
+        //
+        // 0 for "In Names"
+        // 1 for "In Parameters"
+        // 2 for "In Return Types"
+        currentTab: 0,
+        // tab and back preserves the element that was focused.
+        focusedByTab: [null, null, null],
+        clearInputTimeout: () => {
+            if (searchState.timeout !== null) {
+                clearTimeout(searchState.timeout);
+                searchState.timeout = null;
+            }
+        },
+        isDisplayed: () => searchState.outputElement().parentElement.id === ALTERNATIVE_DISPLAY_ID,
+        // Sets the focus on the search bar at the top of the page
+        focus: () => {
+            searchState.input.focus();
+        },
+        // Removes the focus from the search bar.
+        defocus: () => {
+            searchState.input.blur();
+        },
+        showResults: search => {
+            if (search === null || typeof search === "undefined") {
+                search = searchState.outputElement();
+            }
+            switchDisplayedElement(search);
+            searchState.mouseMovedAfterSearch = false;
+            document.title = searchState.title;
+        },
+        hideResults: () => {
+            switchDisplayedElement(null);
+            document.title = searchState.titleBeforeSearch;
+            // We also remove the query parameter from the URL.
+            if (browserSupportsHistoryApi()) {
+                history.replaceState(null, window.currentCrate + " - Rust",
+                    getNakedUrl() + window.location.hash);
+            }
+        },
+        getQueryStringParams: () => {
+            const params = {};
+            window.location.search.substring(1).split("&").
+                map(s => {
+                    const pair = s.split("=");
+                    params[decodeURIComponent(pair[0])] =
+                        typeof pair[1] === "undefined" ? null : decodeURIComponent(pair[1]);
+                });
+            return params;
+        },
+        setup: () => {
+            const search_input = searchState.input;
+            if (!searchState.input) {
+                return;
+            }
+            let searchLoaded = false;
+            function loadSearch() {
+                if (!searchLoaded) {
+                    searchLoaded = true;
+                    loadScript(resourcePath("search", ".js"));
+                    loadScript(resourcePath("search-index", ".js"));
+                }
+            }
+
+            search_input.addEventListener("focus", () => {
+                search_input.origPlaceholder = search_input.placeholder;
+                search_input.placeholder = "Type your search here.";
+                loadSearch();
+            });
+
+            if (search_input.value !== "") {
+                loadSearch();
+            }
+
+            const params = searchState.getQueryStringParams();
+            if (params.search !== undefined) {
+                const search = searchState.outputElement();
+                search.innerHTML = "<h3 class=\"search-loading\">" +
+                    searchState.loadingText + "</h3>";
+                searchState.showResults(search);
+                loadSearch();
+            }
+        },
+    };
+
+    function getPageId() {
+        if (window.location.hash) {
+            const tmp = window.location.hash.replace(/^#/, "");
+            if (tmp.length > 0) {
+                return tmp;
+            }
+        }
+        return null;
+    }
+
+    const toggleAllDocsId = "toggle-all-docs";
+    let savedHash = "";
+
+    function handleHashes(ev) {
+        if (ev !== null && searchState.isDisplayed() && ev.newURL) {
+            // This block occurs when clicking on an element in the navbar while
+            // in a search.
+            switchDisplayedElement(null);
+            const hash = ev.newURL.slice(ev.newURL.indexOf("#") + 1);
+            if (browserSupportsHistoryApi()) {
+                // `window.location.search`` contains all the query parameters, not just `search`.
+                history.replaceState(null, "",
+                    getNakedUrl() + window.location.search + "#" + hash);
+            }
+            const elem = document.getElementById(hash);
+            if (elem) {
+                elem.scrollIntoView();
+            }
+        }
+        // This part is used in case an element is not visible.
+        if (savedHash !== window.location.hash) {
+            savedHash = window.location.hash;
+            if (savedHash.length === 0) {
+                return;
+            }
+            expandSection(savedHash.slice(1)); // we remove the '#'
+        }
+    }
+
+    function onHashChange(ev) {
+        // If we're in mobile mode, we should hide the sidebar in any case.
+        const sidebar = document.getElementsByClassName("sidebar")[0];
+        removeClass(sidebar, "shown");
+        handleHashes(ev);
+    }
+
+    function openParentDetails(elem) {
+        while (elem) {
+            if (elem.tagName === "DETAILS") {
+                elem.open = true;
+            }
+            elem = elem.parentNode;
+        }
+    }
+
+    function expandSection(id) {
+        openParentDetails(document.getElementById(id));
+    }
+
+    function handleEscape(ev) {
+        searchState.clearInputTimeout();
+        switchDisplayedElement(null);
+        if (browserSupportsHistoryApi()) {
+            history.replaceState(null, window.currentCrate + " - Rust",
+                getNakedUrl() + window.location.hash);
+        }
+        ev.preventDefault();
+        searchState.defocus();
+        window.hidePopoverMenus();
+    }
+
+    function handleShortcut(ev) {
+        // Don't interfere with browser shortcuts
+        const disableShortcuts = getSettingValue("disable-shortcuts") === "true";
+        if (ev.ctrlKey || ev.altKey || ev.metaKey || disableShortcuts) {
+            return;
+        }
+
+        if (document.activeElement.tagName === "INPUT" &&
+            document.activeElement.type !== "checkbox") {
+            switch (getVirtualKey(ev)) {
+            case "Escape":
+                handleEscape(ev);
+                break;
+            }
+        } else {
+            switch (getVirtualKey(ev)) {
+            case "Escape":
+                handleEscape(ev);
+                break;
+
+            case "s":
+            case "S":
+                ev.preventDefault();
+                searchState.focus();
+                break;
+
+            case "+":
+            case "-":
+                ev.preventDefault();
+                toggleAllDocs();
+                break;
+
+            case "?":
+                showHelp();
+                break;
+
+            default:
+                break;
+            }
+        }
+    }
+
+    document.addEventListener("keypress", handleShortcut);
+    document.addEventListener("keydown", handleShortcut);
+
+    function addSidebarItems() {
+        if (!window.SIDEBAR_ITEMS) {
+            return;
+        }
+        const sidebar = document.getElementsByClassName("sidebar-elems")[0];
+
+        /**
+         * Append to the sidebar a "block" of links - a heading along with a list (`<ul>`) of items.
+         *
+         * @param {string} shortty - A short type name, like "primitive", "mod", or "macro"
+         * @param {string} id - The HTML id of the corresponding section on the module page.
+         * @param {string} longty - A long, capitalized, plural name, like "Primitive Types",
+         *                          "Modules", or "Macros".
+         */
+        function block(shortty, id, longty) {
+            const filtered = window.SIDEBAR_ITEMS[shortty];
+            if (!filtered) {
+                return;
+            }
+
+            const div = document.createElement("div");
+            div.className = "block " + shortty;
+            const h3 = document.createElement("h3");
+            h3.innerHTML = `<a href="index.html#${id}">${longty}</a>`;
+            div.appendChild(h3);
+            const ul = document.createElement("ul");
+
+            for (const item of filtered) {
+                const name = item[0];
+                const desc = item[1]; // can be null
+
+                let klass = shortty;
+                let path;
+                if (shortty === "mod") {
+                    path = name + "/index.html";
+                } else {
+                    path = shortty + "." + name + ".html";
+                }
+                const current_page = document.location.href.split("/").pop();
+                if (path === current_page) {
+                    klass += " current";
+                }
+                const link = document.createElement("a");
+                link.href = path;
+                link.title = desc;
+                link.className = klass;
+                link.textContent = name;
+                const li = document.createElement("li");
+                li.appendChild(link);
+                ul.appendChild(li);
+            }
+            div.appendChild(ul);
+            sidebar.appendChild(div);
+        }
+
+        if (sidebar) {
+            block("primitive", "primitives", "Primitive Types");
+            block("mod", "modules", "Modules");
+            block("macro", "macros", "Macros");
+            block("struct", "structs", "Structs");
+            block("enum", "enums", "Enums");
+            block("union", "unions", "Unions");
+            block("constant", "constants", "Constants");
+            block("static", "static", "Statics");
+            block("trait", "traits", "Traits");
+            block("fn", "functions", "Functions");
+            block("type", "types", "Type Definitions");
+            block("foreigntype", "foreign-types", "Foreign Types");
+            block("keyword", "keywords", "Keywords");
+            block("traitalias", "trait-aliases", "Trait Aliases");
+        }
+    }
+
+    window.register_implementors = imp => {
+        const implementors = document.getElementById("implementors-list");
+        const synthetic_implementors = document.getElementById("synthetic-implementors-list");
+        const inlined_types = new Set();
+
+        if (synthetic_implementors) {
+            // This `inlined_types` variable is used to avoid having the same implementation
+            // showing up twice. For example "String" in the "Sync" doc page.
+            //
+            // By the way, this is only used by and useful for traits implemented automatically
+            // (like "Send" and "Sync").
+            onEachLazy(synthetic_implementors.getElementsByClassName("impl"), el => {
+                const aliases = el.getAttribute("data-aliases");
+                if (!aliases) {
+                    return;
+                }
+                aliases.split(",").forEach(alias => {
+                    inlined_types.add(alias);
+                });
+            });
+        }
+
+        let currentNbImpls = implementors.getElementsByClassName("impl").length;
+        const traitName = document.querySelector("h1.fqn > .in-band > .trait").textContent;
+        const baseIdName = "impl-" + traitName + "-";
+        const libs = Object.getOwnPropertyNames(imp);
+        // We don't want to include impls from this JS file, when the HTML already has them.
+        // The current crate should always be ignored. Other crates that should also be
+        // ignored are included in the attribute `data-ignore-extern-crates`.
+        const ignoreExternCrates = document
+            .querySelector("script[data-ignore-extern-crates]")
+            .getAttribute("data-ignore-extern-crates");
+        for (const lib of libs) {
+            if (lib === window.currentCrate || ignoreExternCrates.indexOf(lib) !== -1) {
+                continue;
+            }
+            const structs = imp[lib];
+
+            struct_loop:
+            for (const struct of structs) {
+                const list = struct.synthetic ? synthetic_implementors : implementors;
+
+                if (struct.synthetic) {
+                    for (const struct_type of struct.types) {
+                        if (inlined_types.has(struct_type)) {
+                            continue struct_loop;
+                        }
+                        inlined_types.add(struct_type);
+                    }
+                }
+
+                const code = document.createElement("h3");
+                code.innerHTML = struct.text;
+                addClass(code, "code-header");
+                addClass(code, "in-band");
+
+                onEachLazy(code.getElementsByTagName("a"), elem => {
+                    const href = elem.getAttribute("href");
+
+                    if (href && href.indexOf("http") !== 0) {
+                        elem.setAttribute("href", window.rootPath + href);
+                    }
+                });
+
+                const currentId = baseIdName + currentNbImpls;
+                const anchor = document.createElement("a");
+                anchor.href = "#" + currentId;
+                addClass(anchor, "anchor");
+
+                const display = document.createElement("div");
+                display.id = currentId;
+                addClass(display, "impl");
+                display.appendChild(anchor);
+                display.appendChild(code);
+                list.appendChild(display);
+                currentNbImpls += 1;
+            }
+        }
+    };
+    if (window.pending_implementors) {
+        window.register_implementors(window.pending_implementors);
+    }
+
+    function addSidebarCrates() {
+        if (!window.ALL_CRATES) {
+            return;
+        }
+        const sidebarElems = document.getElementsByClassName("sidebar-elems")[0];
+        if (!sidebarElems) {
+            return;
+        }
+        // Draw a convenient sidebar of known crates if we have a listing
+        const div = document.createElement("div");
+        div.className = "block crate";
+        div.innerHTML = "<h3>Crates</h3>";
+        const ul = document.createElement("ul");
+        div.appendChild(ul);
+
+        for (const crate of window.ALL_CRATES) {
+            let klass = "crate";
+            if (window.rootPath !== "./" && crate === window.currentCrate) {
+                klass += " current";
+            }
+            const link = document.createElement("a");
+            link.href = window.rootPath + crate + "/index.html";
+            link.className = klass;
+            link.textContent = crate;
+
+            const li = document.createElement("li");
+            li.appendChild(link);
+            ul.appendChild(li);
+        }
+        sidebarElems.appendChild(div);
+    }
+
+
+    function labelForToggleButton(sectionIsCollapsed) {
+        if (sectionIsCollapsed) {
+            // button will expand the section
+            return "+";
+        }
+        // button will collapse the section
+        // note that this text is also set in the HTML template in ../render/mod.rs
+        return "\u2212"; // "\u2212" is "−" minus sign
+    }
+
+    function toggleAllDocs() {
+        const innerToggle = document.getElementById(toggleAllDocsId);
+        if (!innerToggle) {
+            return;
+        }
+        let sectionIsCollapsed = false;
+        if (hasClass(innerToggle, "will-expand")) {
+            removeClass(innerToggle, "will-expand");
+            onEachLazy(document.getElementsByClassName("rustdoc-toggle"), e => {
+                if (!hasClass(e, "type-contents-toggle")) {
+                    e.open = true;
+                }
+            });
+            innerToggle.title = "collapse all docs";
+        } else {
+            addClass(innerToggle, "will-expand");
+            onEachLazy(document.getElementsByClassName("rustdoc-toggle"), e => {
+                if (e.parentNode.id !== "implementations-list" ||
+                    (!hasClass(e, "implementors-toggle") &&
+                     !hasClass(e, "type-contents-toggle"))
+                ) {
+                    e.open = false;
+                }
+            });
+            sectionIsCollapsed = true;
+            innerToggle.title = "expand all docs";
+        }
+        innerToggle.children[0].innerText = labelForToggleButton(sectionIsCollapsed);
+    }
+
+    (function() {
+        const toggles = document.getElementById(toggleAllDocsId);
+        if (toggles) {
+            toggles.onclick = toggleAllDocs;
+        }
+
+        const hideMethodDocs = getSettingValue("auto-hide-method-docs") === "true";
+        const hideImplementations = getSettingValue("auto-hide-trait-implementations") === "true";
+        const hideLargeItemContents = getSettingValue("auto-hide-large-items") !== "false";
+
+        function setImplementorsTogglesOpen(id, open) {
+            const list = document.getElementById(id);
+            if (list !== null) {
+                onEachLazy(list.getElementsByClassName("implementors-toggle"), e => {
+                    e.open = open;
+                });
+            }
+        }
+
+        if (hideImplementations) {
+            setImplementorsTogglesOpen("trait-implementations-list", false);
+            setImplementorsTogglesOpen("blanket-implementations-list", false);
+        }
+
+        onEachLazy(document.getElementsByClassName("rustdoc-toggle"), e => {
+            if (!hideLargeItemContents && hasClass(e, "type-contents-toggle")) {
+                e.open = true;
+            }
+            if (hideMethodDocs && hasClass(e, "method-toggle")) {
+                e.open = false;
+            }
+
+        });
+
+        const pageId = getPageId();
+        if (pageId !== null) {
+            expandSection(pageId);
+        }
+    }());
+
+    (function() {
+        // To avoid checking on "rustdoc-line-numbers" value on every loop...
+        let lineNumbersFunc = () => {};
+        if (getSettingValue("line-numbers") === "true") {
+            lineNumbersFunc = x => {
+                const count = x.textContent.split("\n").length;
+                const elems = [];
+                for (let i = 0; i < count; ++i) {
+                    elems.push(i + 1);
+                }
+                const node = document.createElement("pre");
+                addClass(node, "line-number");
+                node.innerHTML = elems.join("\n");
+                x.parentNode.insertBefore(node, x);
+            };
+        }
+        onEachLazy(document.getElementsByClassName("rust-example-rendered"), e => {
+            if (hasClass(e, "compile_fail")) {
+                e.addEventListener("mouseover", function() {
+                    this.parentElement.previousElementSibling.childNodes[0].style.color = "#f00";
+                });
+                e.addEventListener("mouseout", function() {
+                    this.parentElement.previousElementSibling.childNodes[0].style.color = "";
+                });
+            } else if (hasClass(e, "ignore")) {
+                e.addEventListener("mouseover", function() {
+                    this.parentElement.previousElementSibling.childNodes[0].style.color = "#ff9200";
+                });
+                e.addEventListener("mouseout", function() {
+                    this.parentElement.previousElementSibling.childNodes[0].style.color = "";
+                });
+            }
+            lineNumbersFunc(e);
+        });
+    }());
+
+    function hideSidebar() {
+        const sidebar = document.getElementsByClassName("sidebar")[0];
+        removeClass(sidebar, "shown");
+    }
+
+    function handleClick(id, f) {
+        const elem = document.getElementById(id);
+        if (elem) {
+            elem.addEventListener("click", f);
+        }
+    }
+    handleClick(MAIN_ID, () => {
+        hideSidebar();
+    });
+
+    onEachLazy(document.getElementsByTagName("a"), el => {
+        // For clicks on internal links (<A> tags with a hash property), we expand the section we're
+        // jumping to *before* jumping there. We can't do this in onHashChange, because it changes
+        // the height of the document so we wind up scrolled to the wrong place.
+        if (el.hash) {
+            el.addEventListener("click", () => {
+                expandSection(el.hash.slice(1));
+                hideSidebar();
+            });
+        }
+    });
+
+    onEachLazy(document.querySelectorAll(".rustdoc-toggle > summary:not(.hideme)"), el => {
+        el.addEventListener("click", e => {
+            if (e.target.tagName !== "SUMMARY" && e.target.tagName !== "A") {
+                e.preventDefault();
+            }
+        });
+    });
+
+    onEachLazy(document.getElementsByClassName("notable-traits"), e => {
+        e.onclick = function() {
+            this.getElementsByClassName("notable-traits-tooltiptext")[0]
+                .classList.toggle("force-tooltip");
+        };
+    });
+
+    const sidebar_menu_toggle = document.getElementsByClassName("sidebar-menu-toggle")[0];
+    if (sidebar_menu_toggle) {
+        sidebar_menu_toggle.addEventListener("click", () => {
+            const sidebar = document.getElementsByClassName("sidebar")[0];
+            if (!hasClass(sidebar, "shown")) {
+                addClass(sidebar, "shown");
+            } else {
+                removeClass(sidebar, "shown");
+            }
+        });
+    }
+
+    function helpBlurHandler(event) {
+        blurHandler(event, getHelpButton(), window.hidePopoverMenus);
+    }
+
+    function buildHelpMenu() {
+        const book_info = document.createElement("span");
+        book_info.className = "top";
+        book_info.innerHTML = "You can find more information in \
+            <a href=\"https://doc.rust-lang.org/rustdoc/\">the rustdoc book</a>.";
+
+        const shortcuts = [
+            ["?", "Show this help dialog"],
+            ["S", "Focus the search field"],
+            ["↑", "Move up in search results"],
+            ["↓", "Move down in search results"],
+            ["← / →", "Switch result tab (when results focused)"],
+            ["&#9166;", "Go to active search result"],
+            ["+", "Expand all sections"],
+            ["-", "Collapse all sections"],
+        ].map(x => "<dt>" +
+            x[0].split(" ")
+                .map((y, index) => ((index & 1) === 0 ? "<kbd>" + y + "</kbd>" : " " + y + " "))
+                .join("") + "</dt><dd>" + x[1] + "</dd>").join("");
+        const div_shortcuts = document.createElement("div");
+        addClass(div_shortcuts, "shortcuts");
+        div_shortcuts.innerHTML = "<h2>Keyboard Shortcuts</h2><dl>" + shortcuts + "</dl></div>";
+
+        const infos = [
+            "Prefix searches with a type followed by a colon (e.g., <code>fn:</code>) to \
+             restrict the search to a given item kind.",
+            "Accepted kinds are: <code>fn</code>, <code>mod</code>, <code>struct</code>, \
+             <code>enum</code>, <code>trait</code>, <code>type</code>, <code>macro</code>, \
+             and <code>const</code>.",
+            "Search functions by type signature (e.g., <code>vec -&gt; usize</code> or \
+             <code>-&gt; vec</code>)",
+            "Search multiple things at once by splitting your query with comma (e.g., \
+             <code>str,u8</code> or <code>String,struct:Vec,test</code>)",
+            "You can look for items with an exact name by putting double quotes around \
+             your request: <code>\"string\"</code>",
+            "Look for items inside another one by searching for a path: <code>vec::Vec</code>",
+        ].map(x => "<p>" + x + "</p>").join("");
+        const div_infos = document.createElement("div");
+        addClass(div_infos, "infos");
+        div_infos.innerHTML = "<h2>Search Tricks</h2>" + infos;
+
+        const rustdoc_version = document.createElement("span");
+        rustdoc_version.className = "bottom";
+        const rustdoc_version_code = document.createElement("code");
+        rustdoc_version_code.innerText = "rustdoc " + getVar("rustdoc-version");
+        rustdoc_version.appendChild(rustdoc_version_code);
+
+        const container = document.createElement("div");
+        container.className = "popover";
+        container.style.display = "none";
+
+        const side_by_side = document.createElement("div");
+        side_by_side.className = "side-by-side";
+        side_by_side.appendChild(div_shortcuts);
+        side_by_side.appendChild(div_infos);
+
+        container.appendChild(book_info);
+        container.appendChild(side_by_side);
+        container.appendChild(rustdoc_version);
+
+        const help_button = getHelpButton();
+        help_button.appendChild(container);
+
+        container.onblur = helpBlurHandler;
+        container.onclick = event => {
+            event.preventDefault();
+        };
+        help_button.onblur = helpBlurHandler;
+        help_button.children[0].onblur = helpBlurHandler;
+
+        return container;
+    }
+
+    /**
+     * Hide all the popover menus.
+     */
+    window.hidePopoverMenus = function() {
+        onEachLazy(document.querySelectorAll(".search-container .popover"), elem => {
+            elem.style.display = "none";
+        });
+    };
+
+    /**
+     * Returns the help menu element (not the button).
+     *
+     * @param {boolean} buildNeeded - If this argument is `false`, the help menu element won't be
+     *                                built if it doesn't exist.
+     *
+     * @return {HTMLElement}
+     */
+    function getHelpMenu(buildNeeded) {
+        let menu = getHelpButton().querySelector(".popover");
+        if (!menu && buildNeeded) {
+            menu = buildHelpMenu();
+        }
+        return menu;
+    }
+
+    /**
+     * Show the help popup menu.
+     */
+    function showHelp() {
+        const menu = getHelpMenu(true);
+        if (menu.style.display === "none") {
+            window.hidePopoverMenus();
+            menu.style.display = "";
+        }
+    }
+
+    document.querySelector(`#${HELP_BUTTON_ID} > button`).addEventListener("click", event => {
+        const target = event.target;
+        if (target.tagName !== "BUTTON" || target.parentElement.id !== HELP_BUTTON_ID) {
+            return;
+        }
+        const menu = getHelpMenu(true);
+        const shouldShowHelp = menu.style.display === "none";
+        if (shouldShowHelp) {
+            showHelp();
+        } else {
+            window.hidePopoverMenus();
+        }
+    });
+
+    setMobileTopbar();
+    addSidebarItems();
+    addSidebarCrates();
+    onHashChange(null);
+    window.addEventListener("hashchange", onHashChange);
+    searchState.setup();
+}());
+
+(function() {
+    let reset_button_timeout = null;
+
+    window.copy_path = but => {
+        const parent = but.parentElement;
+        const path = [];
+
+        onEach(parent.childNodes, child => {
+            if (child.tagName === "A") {
+                path.push(child.textContent);
+            }
+        });
+
+        const el = document.createElement("textarea");
+        el.value = path.join("::");
+        el.setAttribute("readonly", "");
+        // To not make it appear on the screen.
+        el.style.position = "absolute";
+        el.style.left = "-9999px";
+
+        document.body.appendChild(el);
+        el.select();
+        document.execCommand("copy");
+        document.body.removeChild(el);
+
+        // There is always one children, but multiple childNodes.
+        but.children[0].style.display = "none";
+
+        let tmp;
+        if (but.childNodes.length < 2) {
+            tmp = document.createTextNode("✓");
+            but.appendChild(tmp);
+        } else {
+            onEachLazy(but.childNodes, e => {
+                if (e.nodeType === Node.TEXT_NODE) {
+                    tmp = e;
+                    return true;
+                }
+            });
+            tmp.textContent = "✓";
+        }
+
+        if (reset_button_timeout !== null) {
+            window.clearTimeout(reset_button_timeout);
+        }
+
+        function reset_button() {
+            tmp.textContent = "";
+            reset_button_timeout = null;
+            but.children[0].style.display = "";
+        }
+
+        reset_button_timeout = window.setTimeout(reset_button, 1000);
+    };
+}());
diff --git a/src/librustdoc/html/static/js/scrape-examples.js b/src/librustdoc/html/static/js/scrape-examples.js
new file mode 100644
index 000000000..fd7a14497
--- /dev/null
+++ b/src/librustdoc/html/static/js/scrape-examples.js
@@ -0,0 +1,106 @@
+/* global addClass, hasClass, removeClass, onEachLazy */
+
+"use strict";
+
+(function() {
+    // Number of lines shown when code viewer is not expanded
+    const MAX_LINES = 10;
+
+    // Scroll code block to the given code location
+    function scrollToLoc(elt, loc) {
+        const lines = elt.querySelector(".line-numbers");
+        let scrollOffset;
+
+        // If the block is greater than the size of the viewer,
+        // then scroll to the top of the block. Otherwise scroll
+        // to the middle of the block.
+        if (loc[1] - loc[0] > MAX_LINES) {
+            const line = Math.max(0, loc[0] - 1);
+            scrollOffset = lines.children[line].offsetTop;
+        } else {
+            const wrapper = elt.querySelector(".code-wrapper");
+            const halfHeight = wrapper.offsetHeight / 2;
+            const offsetMid = (lines.children[loc[0]].offsetTop
+                             + lines.children[loc[1]].offsetTop) / 2;
+            scrollOffset = offsetMid - halfHeight;
+        }
+
+        lines.scrollTo(0, scrollOffset);
+        elt.querySelector(".rust").scrollTo(0, scrollOffset);
+    }
+
+    function updateScrapedExample(example) {
+        const locs = JSON.parse(example.attributes.getNamedItem("data-locs").textContent);
+        let locIndex = 0;
+        const highlights = Array.prototype.slice.call(example.querySelectorAll(".highlight"));
+        const link = example.querySelector(".scraped-example-title a");
+
+        if (locs.length > 1) {
+            // Toggle through list of examples in a given file
+            const onChangeLoc = changeIndex => {
+                removeClass(highlights[locIndex], "focus");
+                changeIndex();
+                scrollToLoc(example, locs[locIndex][0]);
+                addClass(highlights[locIndex], "focus");
+
+                const url = locs[locIndex][1];
+                const title = locs[locIndex][2];
+
+                link.href = url;
+                link.innerHTML = title;
+            };
+
+            example.querySelector(".prev")
+                .addEventListener("click", () => {
+                    onChangeLoc(() => {
+                        locIndex = (locIndex - 1 + locs.length) % locs.length;
+                    });
+                });
+
+            example.querySelector("next")
+                .addEventListener("click", () => {
+                    onChangeLoc(() => {
+                        locIndex = (locIndex + 1) % locs.length;
+                    });
+                });
+        }
+
+        const expandButton = example.querySelector(".expand");
+        if (expandButton) {
+            expandButton.addEventListener("click", () => {
+                if (hasClass(example, "expanded")) {
+                    removeClass(example, "expanded");
+                    scrollToLoc(example, locs[0][0]);
+                } else {
+                    addClass(example, "expanded");
+                }
+            });
+        }
+
+        // Start with the first example in view
+        scrollToLoc(example, locs[0][0]);
+    }
+
+    const firstExamples = document.querySelectorAll(".scraped-example-list > .scraped-example");
+    onEachLazy(firstExamples, updateScrapedExample);
+    onEachLazy(document.querySelectorAll(".more-examples-toggle"), toggle => {
+        // Allow users to click the left border of the <details> section to close it,
+        // since the section can be large and finding the [+] button is annoying.
+        onEachLazy(toggle.querySelectorAll(".toggle-line, .hide-more"), button => {
+            button.addEventListener("click", () => {
+                toggle.open = false;
+            });
+        });
+
+        const moreExamples = toggle.querySelectorAll(".scraped-example");
+        toggle.querySelector("summary").addEventListener("click", () => {
+            // Wrapping in setTimeout ensures the update happens after the elements are actually
+            // visible. This is necessary since updateScrapedExample calls scrollToLoc which
+            // depends on offsetHeight, a property that requires an element to be visible to
+            // compute correctly.
+            setTimeout(() => {
+                onEachLazy(moreExamples, updateScrapedExample);
+            });
+        }, {once: true});
+    });
+})();
diff --git a/src/librustdoc/html/static/js/search.js b/src/librustdoc/html/static/js/search.js
new file mode 100644
index 000000000..75c7bd45a
--- /dev/null
+++ b/src/librustdoc/html/static/js/search.js
@@ -0,0 +1,2297 @@
+/* global addClass, getNakedUrl, getSettingValue */
+/* global onEachLazy, removeClass, searchState, browserSupportsHistoryApi, exports */
+
+"use strict";
+
+(function() {
+// This mapping table should match the discriminants of
+// `rustdoc::formats::item_type::ItemType` type in Rust.
+const itemTypes = [
+    "mod",
+    "externcrate",
+    "import",
+    "struct",
+    "enum",
+    "fn",
+    "type",
+    "static",
+    "trait",
+    "impl",
+    "tymethod",
+    "method",
+    "structfield",
+    "variant",
+    "macro",
+    "primitive",
+    "associatedtype",
+    "constant",
+    "associatedconstant",
+    "union",
+    "foreigntype",
+    "keyword",
+    "existential",
+    "attr",
+    "derive",
+    "traitalias",
+];
+
+// used for special search precedence
+const TY_PRIMITIVE = itemTypes.indexOf("primitive");
+const TY_KEYWORD = itemTypes.indexOf("keyword");
+const ROOT_PATH = typeof window !== "undefined" ? window.rootPath : "../";
+
+function hasOwnPropertyRustdoc(obj, property) {
+    return Object.prototype.hasOwnProperty.call(obj, property);
+}
+
+// In the search display, allows to switch between tabs.
+function printTab(nb) {
+    let iter = 0;
+    let foundCurrentTab = false;
+    let foundCurrentResultSet = false;
+    onEachLazy(document.getElementById("titles").childNodes, elem => {
+        if (nb === iter) {
+            addClass(elem, "selected");
+            foundCurrentTab = true;
+        } else {
+            removeClass(elem, "selected");
+        }
+        iter += 1;
+    });
+    iter = 0;
+    onEachLazy(document.getElementById("results").childNodes, elem => {
+        if (nb === iter) {
+            addClass(elem, "active");
+            foundCurrentResultSet = true;
+        } else {
+            removeClass(elem, "active");
+        }
+        iter += 1;
+    });
+    if (foundCurrentTab && foundCurrentResultSet) {
+        searchState.currentTab = nb;
+    } else if (nb !== 0) {
+        printTab(0);
+    }
+}
+
+/**
+ * A function to compute the Levenshtein distance between two strings
+ * Licensed under the Creative Commons Attribution-ShareAlike 3.0 Unported
+ * Full License can be found at http://creativecommons.org/licenses/by-sa/3.0/legalcode
+ * This code is an unmodified version of the code written by Marco de Wit
+ * and was found at https://stackoverflow.com/a/18514751/745719
+ */
+const levenshtein_row2 = [];
+function levenshtein(s1, s2) {
+    if (s1 === s2) {
+        return 0;
+    }
+    const s1_len = s1.length, s2_len = s2.length;
+    if (s1_len && s2_len) {
+        let i1 = 0, i2 = 0, a, b, c, c2;
+        const row = levenshtein_row2;
+        while (i1 < s1_len) {
+            row[i1] = ++i1;
+        }
+        while (i2 < s2_len) {
+            c2 = s2.charCodeAt(i2);
+            a = i2;
+            ++i2;
+            b = i2;
+            for (i1 = 0; i1 < s1_len; ++i1) {
+                c = a + (s1.charCodeAt(i1) !== c2 ? 1 : 0);
+                a = row[i1];
+                b = b < a ? (b < c ? b + 1 : c) : (a < c ? a + 1 : c);
+                row[i1] = b;
+            }
+        }
+        return b;
+    }
+    return s1_len + s2_len;
+}
+
+function initSearch(rawSearchIndex) {
+    const MAX_LEV_DISTANCE = 3;
+    const MAX_RESULTS = 200;
+    const NO_TYPE_FILTER = -1;
+    /**
+     *  @type {Array<Row>}
+     */
+    let searchIndex;
+    let currentResults;
+    const ALIASES = Object.create(null);
+
+    function isWhitespace(c) {
+        return " \t\n\r".indexOf(c) !== -1;
+    }
+
+    function isSpecialStartCharacter(c) {
+        return "<\"".indexOf(c) !== -1;
+    }
+
+    function isEndCharacter(c) {
+        return ",>-".indexOf(c) !== -1;
+    }
+
+    function isStopCharacter(c) {
+        return isWhitespace(c) || isEndCharacter(c);
+    }
+
+    function isErrorCharacter(c) {
+        return "()".indexOf(c) !== -1;
+    }
+
+    function itemTypeFromName(typename) {
+        for (let i = 0, len = itemTypes.length; i < len; ++i) {
+            if (itemTypes[i] === typename) {
+                return i;
+            }
+        }
+
+        throw new Error("Unknown type filter `" + typename + "`");
+    }
+
+    /**
+     * If we encounter a `"`, then we try to extract the string from it until we find another `"`.
+     *
+     * This function will throw an error in the following cases:
+     * * There is already another string element.
+     * * We are parsing a generic argument.
+     * * There is more than one element.
+     * * There is no closing `"`.
+     *
+     * @param {ParsedQuery} query
+     * @param {ParserState} parserState
+     * @param {boolean} isInGenerics
+     */
+    function getStringElem(query, parserState, isInGenerics) {
+        if (isInGenerics) {
+            throw new Error("`\"` cannot be used in generics");
+        } else if (query.literalSearch) {
+            throw new Error("Cannot have more than one literal search element");
+        } else if (parserState.totalElems - parserState.genericsElems > 0) {
+            throw new Error("Cannot use literal search when there is more than one element");
+        }
+        parserState.pos += 1;
+        const start = parserState.pos;
+        const end = getIdentEndPosition(parserState);
+        if (parserState.pos >= parserState.length) {
+            throw new Error("Unclosed `\"`");
+        } else if (parserState.userQuery[end] !== "\"") {
+            throw new Error(`Unexpected \`${parserState.userQuery[end]}\` in a string element`);
+        } else if (start === end) {
+            throw new Error("Cannot have empty string element");
+        }
+        // To skip the quote at the end.
+        parserState.pos += 1;
+        query.literalSearch = true;
+    }
+
+    /**
+     * Returns `true` if the current parser position is starting with "::".
+     *
+     * @param {ParserState} parserState
+     *
+     * @return {boolean}
+     */
+    function isPathStart(parserState) {
+        return parserState.userQuery.slice(parserState.pos, parserState.pos + 2) === "::";
+    }
+
+    /**
+     * Returns `true` if the current parser position is starting with "->".
+     *
+     * @param {ParserState} parserState
+     *
+     * @return {boolean}
+     */
+    function isReturnArrow(parserState) {
+        return parserState.userQuery.slice(parserState.pos, parserState.pos + 2) === "->";
+    }
+
+    /**
+     * Returns `true` if the given `c` character is valid for an ident.
+     *
+     * @param {string} c
+     *
+     * @return {boolean}
+     */
+    function isIdentCharacter(c) {
+        return (
+            c === "_" ||
+            (c >= "0" && c <= "9") ||
+            (c >= "a" && c <= "z") ||
+            (c >= "A" && c <= "Z"));
+    }
+
+    /**
+     * Returns `true` if the given `c` character is a separator.
+     *
+     * @param {string} c
+     *
+     * @return {boolean}
+     */
+    function isSeparatorCharacter(c) {
+        return c === "," || isWhitespaceCharacter(c);
+    }
+
+    /**
+     * Returns `true` if the given `c` character is a whitespace.
+     *
+     * @param {string} c
+     *
+     * @return {boolean}
+     */
+    function isWhitespaceCharacter(c) {
+        return c === " " || c === "\t";
+    }
+
+    /**
+     * @param {ParsedQuery} query
+     * @param {ParserState} parserState
+     * @param {string} name                  - Name of the query element.
+     * @param {Array<QueryElement>} generics - List of generics of this query element.
+     *
+     * @return {QueryElement}                - The newly created `QueryElement`.
+     */
+    function createQueryElement(query, parserState, name, generics, isInGenerics) {
+        if (name === "*" || (name.length === 0 && generics.length === 0)) {
+            return;
+        }
+        if (query.literalSearch && parserState.totalElems - parserState.genericsElems > 0) {
+            throw new Error("You cannot have more than one element if you use quotes");
+        }
+        const pathSegments = name.split("::");
+        if (pathSegments.length > 1) {
+            for (let i = 0, len = pathSegments.length; i < len; ++i) {
+                const pathSegment = pathSegments[i];
+
+                if (pathSegment.length === 0) {
+                    if (i === 0) {
+                        throw new Error("Paths cannot start with `::`");
+                    } else if (i + 1 === len) {
+                        throw new Error("Paths cannot end with `::`");
+                    }
+                    throw new Error("Unexpected `::::`");
+                }
+            }
+        }
+        // In case we only have something like `<p>`, there is no name.
+        if (pathSegments.length === 0 || (pathSegments.length === 1 && pathSegments[0] === "")) {
+            throw new Error("Found generics without a path");
+        }
+        parserState.totalElems += 1;
+        if (isInGenerics) {
+            parserState.genericsElems += 1;
+        }
+        return {
+            name: name,
+            fullPath: pathSegments,
+            pathWithoutLast: pathSegments.slice(0, pathSegments.length - 1),
+            pathLast: pathSegments[pathSegments.length - 1],
+            generics: generics,
+        };
+    }
+
+    /**
+     * This function goes through all characters until it reaches an invalid ident character or the
+     * end of the query. It returns the position of the last character of the ident.
+     *
+     * @param {ParserState} parserState
+     *
+     * @return {integer}
+     */
+    function getIdentEndPosition(parserState) {
+        let end = parserState.pos;
+        let foundExclamation = false;
+        while (parserState.pos < parserState.length) {
+            const c = parserState.userQuery[parserState.pos];
+            if (!isIdentCharacter(c)) {
+                if (c === "!") {
+                    if (foundExclamation) {
+                        throw new Error("Cannot have more than one `!` in an ident");
+                    } else if (parserState.pos + 1 < parserState.length &&
+                        isIdentCharacter(parserState.userQuery[parserState.pos + 1])
+                    ) {
+                        throw new Error("`!` can only be at the end of an ident");
+                    }
+                    foundExclamation = true;
+                } else if (isErrorCharacter(c)) {
+                    throw new Error(`Unexpected \`${c}\``);
+                } else if (
+                    isStopCharacter(c) ||
+                    isSpecialStartCharacter(c) ||
+                    isSeparatorCharacter(c)
+                ) {
+                    break;
+                } else if (c === ":") { // If we allow paths ("str::string" for example).
+                    if (!isPathStart(parserState)) {
+                        break;
+                    }
+                    // Skip current ":".
+                    parserState.pos += 1;
+                    foundExclamation = false;
+                } else {
+                    throw new Error(`Unexpected \`${c}\``);
+                }
+            }
+            parserState.pos += 1;
+            end = parserState.pos;
+        }
+        return end;
+    }
+
+    /**
+     * @param {ParsedQuery} query
+     * @param {ParserState} parserState
+     * @param {Array<QueryElement>} elems - This is where the new {QueryElement} will be added.
+     * @param {boolean} isInGenerics
+     */
+    function getNextElem(query, parserState, elems, isInGenerics) {
+        const generics = [];
+
+        let start = parserState.pos;
+        let end;
+        // We handle the strings on their own mostly to make code easier to follow.
+        if (parserState.userQuery[parserState.pos] === "\"") {
+            start += 1;
+            getStringElem(query, parserState, isInGenerics);
+            end = parserState.pos - 1;
+        } else {
+            end = getIdentEndPosition(parserState);
+        }
+        if (parserState.pos < parserState.length &&
+            parserState.userQuery[parserState.pos] === "<"
+        ) {
+            if (isInGenerics) {
+                throw new Error("Unexpected `<` after `<`");
+            } else if (start >= end) {
+                throw new Error("Found generics without a path");
+            }
+            parserState.pos += 1;
+            getItemsBefore(query, parserState, generics, ">");
+        }
+        if (start >= end && generics.length === 0) {
+            return;
+        }
+        elems.push(
+            createQueryElement(
+                query,
+                parserState,
+                parserState.userQuery.slice(start, end),
+                generics,
+                isInGenerics
+            )
+        );
+    }
+
+    /**
+     * This function parses the next query element until it finds `endChar`, calling `getNextElem`
+     * to collect each element.
+     *
+     * If there is no `endChar`, this function will implicitly stop at the end without raising an
+     * error.
+     *
+     * @param {ParsedQuery} query
+     * @param {ParserState} parserState
+     * @param {Array<QueryElement>} elems - This is where the new {QueryElement} will be added.
+     * @param {string} endChar            - This function will stop when it'll encounter this
+     *                                      character.
+     */
+    function getItemsBefore(query, parserState, elems, endChar) {
+        let foundStopChar = true;
+
+        while (parserState.pos < parserState.length) {
+            const c = parserState.userQuery[parserState.pos];
+            if (c === endChar) {
+                break;
+            } else if (isSeparatorCharacter(c)) {
+                parserState.pos += 1;
+                foundStopChar = true;
+                continue;
+            } else if (c === ":" && isPathStart(parserState)) {
+                throw new Error("Unexpected `::`: paths cannot start with `::`");
+            } else if (c === ":" || isEndCharacter(c)) {
+                let extra = "";
+                if (endChar === ">") {
+                    extra = "`<`";
+                } else if (endChar === "") {
+                    extra = "`->`";
+                }
+                throw new Error("Unexpected `" + c + "` after " + extra);
+            }
+            if (!foundStopChar) {
+                if (endChar !== "") {
+                    throw new Error(`Expected \`,\`, \` \` or \`${endChar}\`, found \`${c}\``);
+                }
+                throw new Error(`Expected \`,\` or \` \`, found \`${c}\``);
+            }
+            const posBefore = parserState.pos;
+            getNextElem(query, parserState, elems, endChar === ">");
+            // This case can be encountered if `getNextElem` encounted a "stop character" right from
+            // the start. For example if you have `,,` or `<>`. In this case, we simply move up the
+            // current position to continue the parsing.
+            if (posBefore === parserState.pos) {
+                parserState.pos += 1;
+            }
+            foundStopChar = false;
+        }
+        // We are either at the end of the string or on the `endChar`` character, let's move forward
+        // in any case.
+        parserState.pos += 1;
+    }
+
+    /**
+     * Checks that the type filter doesn't have unwanted characters like `<>` (which are ignored
+     * if empty).
+     *
+     * @param {ParserState} parserState
+     */
+    function checkExtraTypeFilterCharacters(parserState) {
+        const query = parserState.userQuery;
+
+        for (let pos = 0; pos < parserState.pos; ++pos) {
+            if (!isIdentCharacter(query[pos]) && !isWhitespaceCharacter(query[pos])) {
+                throw new Error(`Unexpected \`${query[pos]}\` in type filter`);
+            }
+        }
+    }
+
+    /**
+     * Parses the provided `query` input to fill `parserState`. If it encounters an error while
+     * parsing `query`, it'll throw an error.
+     *
+     * @param {ParsedQuery} query
+     * @param {ParserState} parserState
+     */
+    function parseInput(query, parserState) {
+        let c, before;
+        let foundStopChar = true;
+
+        while (parserState.pos < parserState.length) {
+            c = parserState.userQuery[parserState.pos];
+            if (isStopCharacter(c)) {
+                foundStopChar = true;
+                if (isSeparatorCharacter(c)) {
+                    parserState.pos += 1;
+                    continue;
+                } else if (c === "-" || c === ">") {
+                    if (isReturnArrow(parserState)) {
+                        break;
+                    }
+                    throw new Error(`Unexpected \`${c}\` (did you mean \`->\`?)`);
+                }
+                throw new Error(`Unexpected \`${c}\``);
+            } else if (c === ":" && !isPathStart(parserState)) {
+                if (parserState.typeFilter !== null) {
+                    throw new Error("Unexpected `:`");
+                }
+                if (query.elems.length === 0) {
+                    throw new Error("Expected type filter before `:`");
+                } else if (query.elems.length !== 1 || parserState.totalElems !== 1) {
+                    throw new Error("Unexpected `:`");
+                } else if (query.literalSearch) {
+                    throw new Error("You cannot use quotes on type filter");
+                }
+                checkExtraTypeFilterCharacters(parserState);
+                // The type filter doesn't count as an element since it's a modifier.
+                parserState.typeFilter = query.elems.pop().name;
+                parserState.pos += 1;
+                parserState.totalElems = 0;
+                query.literalSearch = false;
+                foundStopChar = true;
+                continue;
+            }
+            if (!foundStopChar) {
+                if (parserState.typeFilter !== null) {
+                    throw new Error(`Expected \`,\`, \` \` or \`->\`, found \`${c}\``);
+                }
+                throw new Error(`Expected \`,\`, \` \`, \`:\` or \`->\`, found \`${c}\``);
+            }
+            before = query.elems.length;
+            getNextElem(query, parserState, query.elems, false);
+            if (query.elems.length === before) {
+                // Nothing was added, weird... Let's increase the position to not remain stuck.
+                parserState.pos += 1;
+            }
+            foundStopChar = false;
+        }
+        while (parserState.pos < parserState.length) {
+            c = parserState.userQuery[parserState.pos];
+            if (isReturnArrow(parserState)) {
+                parserState.pos += 2;
+                // Get returned elements.
+                getItemsBefore(query, parserState, query.returned, "");
+                // Nothing can come afterward!
+                if (query.returned.length === 0) {
+                    throw new Error("Expected at least one item after `->`");
+                }
+                break;
+            } else {
+                parserState.pos += 1;
+            }
+        }
+    }
+
+    /**
+     * Takes the user search input and returns an empty `ParsedQuery`.
+     *
+     * @param {string} userQuery
+     *
+     * @return {ParsedQuery}
+     */
+    function newParsedQuery(userQuery) {
+        return {
+            original: userQuery,
+            userQuery: userQuery.toLowerCase(),
+            typeFilter: NO_TYPE_FILTER,
+            elems: [],
+            returned: [],
+            // Total number of "top" elements (does not include generics).
+            foundElems: 0,
+            literalSearch: false,
+            error: null,
+        };
+    }
+
+    /**
+     * Build an URL with search parameters.
+     *
+     * @param {string} search            - The current search being performed.
+     * @param {string|null} filterCrates - The current filtering crate (if any).
+     *
+     * @return {string}
+     */
+    function buildUrl(search, filterCrates) {
+        let extra = "?search=" + encodeURIComponent(search);
+
+        if (filterCrates !== null) {
+            extra += "&filter-crate=" + encodeURIComponent(filterCrates);
+        }
+        return getNakedUrl() + extra + window.location.hash;
+    }
+
+    /**
+     * Return the filtering crate or `null` if there is none.
+     *
+     * @return {string|null}
+     */
+    function getFilterCrates() {
+        const elem = document.getElementById("crate-search");
+
+        if (elem &&
+            elem.value !== "All crates" &&
+            hasOwnPropertyRustdoc(rawSearchIndex, elem.value)
+        ) {
+            return elem.value;
+        }
+        return null;
+    }
+
+    /**
+     * Parses the query.
+     *
+     * The supported syntax by this parser is as follow:
+     *
+     * ident = *(ALPHA / DIGIT / "_") [!]
+     * path = ident *(DOUBLE-COLON ident)
+     * arg = path [generics]
+     * arg-without-generic = path
+     * type-sep = COMMA/WS *(COMMA/WS)
+     * nonempty-arg-list = *(type-sep) arg *(type-sep arg) *(type-sep)
+     * nonempty-arg-list-without-generics = *(type-sep) arg-without-generic
+     *                                      *(type-sep arg-without-generic) *(type-sep)
+     * generics = OPEN-ANGLE-BRACKET [ nonempty-arg-list-without-generics ] *(type-sep)
+     *            CLOSE-ANGLE-BRACKET/EOF
+     * return-args = RETURN-ARROW *(type-sep) nonempty-arg-list
+     *
+     * exact-search = [type-filter *WS COLON] [ RETURN-ARROW ] *WS QUOTE ident QUOTE [ generics ]
+     * type-search = [type-filter *WS COLON] [ nonempty-arg-list ] [ return-args ]
+     *
+     * query = *WS (exact-search / type-search) *WS
+     *
+     * type-filter = (
+     *     "mod" /
+     *     "externcrate" /
+     *     "import" /
+     *     "struct" /
+     *     "enum" /
+     *     "fn" /
+     *     "type" /
+     *     "static" /
+     *     "trait" /
+     *     "impl" /
+     *     "tymethod" /
+     *     "method" /
+     *     "structfield" /
+     *     "variant" /
+     *     "macro" /
+     *     "primitive" /
+     *     "associatedtype" /
+     *     "constant" /
+     *     "associatedconstant" /
+     *     "union" /
+     *     "foreigntype" /
+     *     "keyword" /
+     *     "existential" /
+     *     "attr" /
+     *     "derive" /
+     *     "traitalias")
+     *
+     * OPEN-ANGLE-BRACKET = "<"
+     * CLOSE-ANGLE-BRACKET = ">"
+     * COLON = ":"
+     * DOUBLE-COLON = "::"
+     * QUOTE = %x22
+     * COMMA = ","
+     * RETURN-ARROW = "->"
+     *
+     * ALPHA = %x41-5A / %x61-7A ; A-Z / a-z
+     * DIGIT = %x30-39
+     * WS = %x09 / " "
+     *
+     * @param  {string} val     - The user query
+     *
+     * @return {ParsedQuery}    - The parsed query
+     */
+    function parseQuery(userQuery) {
+        userQuery = userQuery.trim();
+        const parserState = {
+            length: userQuery.length,
+            pos: 0,
+            // Total number of elements (includes generics).
+            totalElems: 0,
+            genericsElems: 0,
+            typeFilter: null,
+            userQuery: userQuery.toLowerCase(),
+        };
+        let query = newParsedQuery(userQuery);
+
+        try {
+            parseInput(query, parserState);
+            if (parserState.typeFilter !== null) {
+                let typeFilter = parserState.typeFilter;
+                if (typeFilter === "const") {
+                    typeFilter = "constant";
+                }
+                query.typeFilter = itemTypeFromName(typeFilter);
+            }
+        } catch (err) {
+            query = newParsedQuery(userQuery);
+            query.error = err.message;
+            query.typeFilter = -1;
+            return query;
+        }
+
+        if (!query.literalSearch) {
+            // If there is more than one element in the query, we switch to literalSearch in any
+            // case.
+            query.literalSearch = parserState.totalElems > 1;
+        }
+        query.foundElems = query.elems.length + query.returned.length;
+        return query;
+    }
+
+    /**
+     * Creates the query results.
+     *
+     * @param {Array<Result>} results_in_args
+     * @param {Array<Result>} results_returned
+     * @param {Array<Result>} results_in_args
+     * @param {ParsedQuery} parsedQuery
+     *
+     * @return {ResultsTable}
+     */
+    function createQueryResults(results_in_args, results_returned, results_others, parsedQuery) {
+        return {
+            "in_args": results_in_args,
+            "returned": results_returned,
+            "others": results_others,
+            "query": parsedQuery,
+        };
+    }
+
+    /**
+     * Executes the parsed query and builds a {ResultsTable}.
+     *
+     * @param  {ParsedQuery} parsedQuery - The parsed user query
+     * @param  {Object} searchWords      - The list of search words to query against
+     * @param  {Object} [filterCrates]   - Crate to search in if defined
+     * @param  {Object} [currentCrate]   - Current crate, to rank results from this crate higher
+     *
+     * @return {ResultsTable}
+     */
+    function execQuery(parsedQuery, searchWords, filterCrates, currentCrate) {
+        const results_others = {}, results_in_args = {}, results_returned = {};
+
+        function transformResults(results) {
+            const duplicates = {};
+            const out = [];
+
+            for (const result of results) {
+                if (result.id > -1) {
+                    const obj = searchIndex[result.id];
+                    obj.lev = result.lev;
+                    const res = buildHrefAndPath(obj);
+                    obj.displayPath = pathSplitter(res[0]);
+                    obj.fullPath = obj.displayPath + obj.name;
+                    // To be sure than it some items aren't considered as duplicate.
+                    obj.fullPath += "|" + obj.ty;
+
+                    if (duplicates[obj.fullPath]) {
+                        continue;
+                    }
+                    duplicates[obj.fullPath] = true;
+
+                    obj.href = res[1];
+                    out.push(obj);
+                    if (out.length >= MAX_RESULTS) {
+                        break;
+                    }
+                }
+            }
+            return out;
+        }
+
+        function sortResults(results, isType, preferredCrate) {
+            const userQuery = parsedQuery.userQuery;
+            const ar = [];
+            for (const entry in results) {
+                if (hasOwnPropertyRustdoc(results, entry)) {
+                    const result = results[entry];
+                    result.word = searchWords[result.id];
+                    result.item = searchIndex[result.id] || {};
+                    ar.push(result);
+                }
+            }
+            results = ar;
+            // if there are no results then return to default and fail
+            if (results.length === 0) {
+                return [];
+            }
+
+            results.sort((aaa, bbb) => {
+                let a, b;
+
+                // sort by exact match with regard to the last word (mismatch goes later)
+                a = (aaa.word !== userQuery);
+                b = (bbb.word !== userQuery);
+                if (a !== b) {
+                    return a - b;
+                }
+
+                // Sort by non levenshtein results and then levenshtein results by the distance
+                // (less changes required to match means higher rankings)
+                a = (aaa.lev);
+                b = (bbb.lev);
+                if (a !== b) {
+                    return a - b;
+                }
+
+                // sort by crate (current crate comes first)
+                a = (aaa.item.crate !== preferredCrate);
+                b = (bbb.item.crate !== preferredCrate);
+                if (a !== b) {
+                    return a - b;
+                }
+
+                // sort by item name length (longer goes later)
+                a = aaa.word.length;
+                b = bbb.word.length;
+                if (a !== b) {
+                    return a - b;
+                }
+
+                // sort by item name (lexicographically larger goes later)
+                a = aaa.word;
+                b = bbb.word;
+                if (a !== b) {
+                    return (a > b ? +1 : -1);
+                }
+
+                // sort by index of keyword in item name (no literal occurrence goes later)
+                a = (aaa.index < 0);
+                b = (bbb.index < 0);
+                if (a !== b) {
+                    return a - b;
+                }
+                // (later literal occurrence, if any, goes later)
+                a = aaa.index;
+                b = bbb.index;
+                if (a !== b) {
+                    return a - b;
+                }
+
+                // special precedence for primitive and keyword pages
+                if ((aaa.item.ty === TY_PRIMITIVE && bbb.item.ty !== TY_KEYWORD) ||
+                    (aaa.item.ty === TY_KEYWORD && bbb.item.ty !== TY_PRIMITIVE)) {
+                    return -1;
+                }
+                if ((bbb.item.ty === TY_PRIMITIVE && aaa.item.ty !== TY_PRIMITIVE) ||
+                    (bbb.item.ty === TY_KEYWORD && aaa.item.ty !== TY_KEYWORD)) {
+                    return 1;
+                }
+
+                // sort by description (no description goes later)
+                a = (aaa.item.desc === "");
+                b = (bbb.item.desc === "");
+                if (a !== b) {
+                    return a - b;
+                }
+
+                // sort by type (later occurrence in `itemTypes` goes later)
+                a = aaa.item.ty;
+                b = bbb.item.ty;
+                if (a !== b) {
+                    return a - b;
+                }
+
+                // sort by path (lexicographically larger goes later)
+                a = aaa.item.path;
+                b = bbb.item.path;
+                if (a !== b) {
+                    return (a > b ? +1 : -1);
+                }
+
+                // que sera, sera
+                return 0;
+            });
+
+            let nameSplit = null;
+            if (parsedQuery.elems.length === 1) {
+                const hasPath = typeof parsedQuery.elems[0].path === "undefined";
+                nameSplit = hasPath ? null : parsedQuery.elems[0].path;
+            }
+
+            for (const result of results) {
+                // this validation does not make sense when searching by types
+                if (result.dontValidate) {
+                    continue;
+                }
+                const name = result.item.name.toLowerCase(),
+                    path = result.item.path.toLowerCase(),
+                    parent = result.item.parent;
+
+                if (!isType && !validateResult(name, path, nameSplit, parent)) {
+                    result.id = -1;
+                }
+            }
+            return transformResults(results);
+        }
+
+        /**
+         * This function checks if the object (`row`) generics match the given type (`elem`)
+         * generics. If there are no generics on `row`, `defaultLev` is returned.
+         *
+         * @param {Row} row            - The object to check.
+         * @param {QueryElement} elem  - The element from the parsed query.
+         * @param {integer} defaultLev - This is the value to return in case there are no generics.
+         *
+         * @return {integer}           - Returns the best match (if any) or `MAX_LEV_DISTANCE + 1`.
+         */
+        function checkGenerics(row, elem, defaultLev) {
+            if (row.generics.length === 0) {
+                return elem.generics.length === 0 ? defaultLev : MAX_LEV_DISTANCE + 1;
+            } else if (row.generics.length > 0 && row.generics[0].name === null) {
+                return checkGenerics(row.generics[0], elem, defaultLev);
+            }
+            // The names match, but we need to be sure that all generics kinda
+            // match as well.
+            let elem_name;
+            if (elem.generics.length > 0 && row.generics.length >= elem.generics.length) {
+                const elems = Object.create(null);
+                for (const entry of row.generics) {
+                    elem_name = entry.name;
+                    if (elem_name === "") {
+                        // Pure generic, needs to check into it.
+                        if (checkGenerics(entry, elem, MAX_LEV_DISTANCE + 1) !== 0) {
+                            return MAX_LEV_DISTANCE + 1;
+                        }
+                        continue;
+                    }
+                    if (elems[elem_name] === undefined) {
+                        elems[elem_name] = 0;
+                    }
+                    elems[elem_name] += 1;
+                }
+                // We need to find the type that matches the most to remove it in order
+                // to move forward.
+                for (const generic of elem.generics) {
+                    let match = null;
+                    if (elems[generic.name]) {
+                        match = generic.name;
+                    } else {
+                        for (elem_name in elems) {
+                            if (!hasOwnPropertyRustdoc(elems, elem_name)) {
+                                continue;
+                            }
+                            if (elem_name === generic) {
+                                match = elem_name;
+                                break;
+                            }
+                        }
+                    }
+                    if (match === null) {
+                        return MAX_LEV_DISTANCE + 1;
+                    }
+                    elems[match] -= 1;
+                    if (elems[match] === 0) {
+                        delete elems[match];
+                    }
+                }
+                return 0;
+            }
+            return MAX_LEV_DISTANCE + 1;
+        }
+
+        /**
+          * This function checks if the object (`row`) matches the given type (`elem`) and its
+          * generics (if any).
+          *
+          * @param {Row} row
+          * @param {QueryElement} elem    - The element from the parsed query.
+          *
+          * @return {integer} - Returns a Levenshtein distance to the best match.
+          */
+        function checkIfInGenerics(row, elem) {
+            let lev = MAX_LEV_DISTANCE + 1;
+            for (const entry of row.generics) {
+                lev = Math.min(checkType(entry, elem, true), lev);
+                if (lev === 0) {
+                    break;
+                }
+            }
+            return lev;
+        }
+
+        /**
+          * This function checks if the object (`row`) matches the given type (`elem`) and its
+          * generics (if any).
+          *
+          * @param {Row} row
+          * @param {QueryElement} elem      - The element from the parsed query.
+          * @param {boolean} literalSearch
+          *
+          * @return {integer} - Returns a Levenshtein distance to the best match. If there is
+          *                     no match, returns `MAX_LEV_DISTANCE + 1`.
+          */
+        function checkType(row, elem, literalSearch) {
+            if (row.name === null) {
+                // This is a pure "generic" search, no need to run other checks.
+                if (row.generics.length > 0) {
+                    return checkIfInGenerics(row, elem);
+                }
+                return MAX_LEV_DISTANCE + 1;
+            }
+
+            let lev = levenshtein(row.name, elem.name);
+            if (literalSearch) {
+                if (lev !== 0) {
+                    // The name didn't match, let's try to check if the generics do.
+                    if (elem.generics.length === 0) {
+                        const checkGeneric = row.generics.length > 0;
+                        if (checkGeneric && row.generics
+                            .findIndex(tmp_elem => tmp_elem.name === elem.name) !== -1) {
+                            return 0;
+                        }
+                    }
+                    return MAX_LEV_DISTANCE + 1;
+                } else if (elem.generics.length > 0) {
+                    return checkGenerics(row, elem, MAX_LEV_DISTANCE + 1);
+                }
+                return 0;
+            } else if (row.generics.length > 0) {
+                if (elem.generics.length === 0) {
+                    if (lev === 0) {
+                        return 0;
+                    }
+                    // The name didn't match so we now check if the type we're looking for is inside
+                    // the generics!
+                    lev = checkIfInGenerics(row, elem);
+                    // Now whatever happens, the returned distance is "less good" so we should mark
+                    // it as such, and so we add 0.5 to the distance to make it "less good".
+                    return lev + 0.5;
+                } else if (lev > MAX_LEV_DISTANCE) {
+                    // So our item's name doesn't match at all and has generics.
+                    //
+                    // Maybe it's present in a sub generic? For example "f<A<B<C>>>()", if we're
+                    // looking for "B<C>", we'll need to go down.
+                    return checkIfInGenerics(row, elem);
+                } else {
+                    // At this point, the name kinda match and we have generics to check, so
+                    // let's go!
+                    const tmp_lev = checkGenerics(row, elem, lev);
+                    if (tmp_lev > MAX_LEV_DISTANCE) {
+                        return MAX_LEV_DISTANCE + 1;
+                    }
+                    // We compute the median value of both checks and return it.
+                    return (tmp_lev + lev) / 2;
+                }
+            } else if (elem.generics.length > 0) {
+                // In this case, we were expecting generics but there isn't so we simply reject this
+                // one.
+                return MAX_LEV_DISTANCE + 1;
+            }
+            // No generics on our query or on the target type so we can return without doing
+            // anything else.
+            return lev;
+        }
+
+        /**
+         * This function checks if the object (`row`) has an argument with the given type (`elem`).
+         *
+         * @param {Row} row
+         * @param {QueryElement} elem    - The element from the parsed query.
+         * @param {integer} typeFilter
+         *
+         * @return {integer} - Returns a Levenshtein distance to the best match. If there is no
+         *                      match, returns `MAX_LEV_DISTANCE + 1`.
+         */
+        function findArg(row, elem, typeFilter) {
+            let lev = MAX_LEV_DISTANCE + 1;
+
+            if (row && row.type && row.type.inputs && row.type.inputs.length > 0) {
+                for (const input of row.type.inputs) {
+                    if (!typePassesFilter(typeFilter, input.ty)) {
+                        continue;
+                    }
+                    lev = Math.min(lev, checkType(input, elem, parsedQuery.literalSearch));
+                    if (lev === 0) {
+                        return 0;
+                    }
+                }
+            }
+            return parsedQuery.literalSearch ? MAX_LEV_DISTANCE + 1 : lev;
+        }
+
+        /**
+         * This function checks if the object (`row`) returns the given type (`elem`).
+         *
+         * @param {Row} row
+         * @param {QueryElement} elem   - The element from the parsed query.
+         * @param {integer} typeFilter
+         *
+         * @return {integer} - Returns a Levenshtein distance to the best match. If there is no
+         *                      match, returns `MAX_LEV_DISTANCE + 1`.
+         */
+        function checkReturned(row, elem, typeFilter) {
+            let lev = MAX_LEV_DISTANCE + 1;
+
+            if (row && row.type && row.type.output.length > 0) {
+                const ret = row.type.output;
+                for (const ret_ty of ret) {
+                    if (!typePassesFilter(typeFilter, ret_ty.ty)) {
+                        continue;
+                    }
+                    lev = Math.min(lev, checkType(ret_ty, elem, parsedQuery.literalSearch));
+                    if (lev === 0) {
+                        return 0;
+                    }
+                }
+            }
+            return parsedQuery.literalSearch ? MAX_LEV_DISTANCE + 1 : lev;
+        }
+
+        function checkPath(contains, ty) {
+            if (contains.length === 0) {
+                return 0;
+            }
+            let ret_lev = MAX_LEV_DISTANCE + 1;
+            const path = ty.path.split("::");
+
+            if (ty.parent && ty.parent.name) {
+                path.push(ty.parent.name.toLowerCase());
+            }
+
+            const length = path.length;
+            const clength = contains.length;
+            if (clength > length) {
+                return MAX_LEV_DISTANCE + 1;
+            }
+            for (let i = 0; i < length; ++i) {
+                if (i + clength > length) {
+                    break;
+                }
+                let lev_total = 0;
+                let aborted = false;
+                for (let x = 0; x < clength; ++x) {
+                    const lev = levenshtein(path[i + x], contains[x]);
+                    if (lev > MAX_LEV_DISTANCE) {
+                        aborted = true;
+                        break;
+                    }
+                    lev_total += lev;
+                }
+                if (!aborted) {
+                    ret_lev = Math.min(ret_lev, Math.round(lev_total / clength));
+                }
+            }
+            return ret_lev;
+        }
+
+        function typePassesFilter(filter, type) {
+            // No filter or Exact mach
+            if (filter <= NO_TYPE_FILTER || filter === type) return true;
+
+            // Match related items
+            const name = itemTypes[type];
+            switch (itemTypes[filter]) {
+                case "constant":
+                    return name === "associatedconstant";
+                case "fn":
+                    return name === "method" || name === "tymethod";
+                case "type":
+                    return name === "primitive" || name === "associatedtype";
+                case "trait":
+                    return name === "traitalias";
+            }
+
+            // No match
+            return false;
+        }
+
+        function createAliasFromItem(item) {
+            return {
+                crate: item.crate,
+                name: item.name,
+                path: item.path,
+                desc: item.desc,
+                ty: item.ty,
+                parent: item.parent,
+                type: item.type,
+                is_alias: true,
+            };
+        }
+
+        function handleAliases(ret, query, filterCrates, currentCrate) {
+            const lowerQuery = query.toLowerCase();
+            // We separate aliases and crate aliases because we want to have current crate
+            // aliases to be before the others in the displayed results.
+            const aliases = [];
+            const crateAliases = [];
+            if (filterCrates !== null) {
+                if (ALIASES[filterCrates] && ALIASES[filterCrates][lowerQuery]) {
+                    const query_aliases = ALIASES[filterCrates][lowerQuery];
+                    for (const alias of query_aliases) {
+                        aliases.push(createAliasFromItem(searchIndex[alias]));
+                    }
+                }
+            } else {
+                Object.keys(ALIASES).forEach(crate => {
+                    if (ALIASES[crate][lowerQuery]) {
+                        const pushTo = crate === currentCrate ? crateAliases : aliases;
+                        const query_aliases = ALIASES[crate][lowerQuery];
+                        for (const alias of query_aliases) {
+                            pushTo.push(createAliasFromItem(searchIndex[alias]));
+                        }
+                    }
+                });
+            }
+
+            const sortFunc = (aaa, bbb) => {
+                if (aaa.path < bbb.path) {
+                    return 1;
+                } else if (aaa.path === bbb.path) {
+                    return 0;
+                }
+                return -1;
+            };
+            crateAliases.sort(sortFunc);
+            aliases.sort(sortFunc);
+
+            const pushFunc = alias => {
+                alias.alias = query;
+                const res = buildHrefAndPath(alias);
+                alias.displayPath = pathSplitter(res[0]);
+                alias.fullPath = alias.displayPath + alias.name;
+                alias.href = res[1];
+
+                ret.others.unshift(alias);
+                if (ret.others.length > MAX_RESULTS) {
+                    ret.others.pop();
+                }
+            };
+
+            aliases.forEach(pushFunc);
+            crateAliases.forEach(pushFunc);
+        }
+
+        /**
+         * This function adds the given result into the provided `results` map if it matches the
+         * following condition:
+         *
+         * * If it is a "literal search" (`parsedQuery.literalSearch`), then `lev` must be 0.
+         * * If it is not a "literal search", `lev` must be <= `MAX_LEV_DISTANCE`.
+         *
+         * The `results` map contains information which will be used to sort the search results:
+         *
+         * * `fullId` is a `string`` used as the key of the object we use for the `results` map.
+         * * `id` is the index in both `searchWords` and `searchIndex` arrays for this element.
+         * * `index` is an `integer`` used to sort by the position of the word in the item's name.
+         * * `lev` is the main metric used to sort the search results.
+         *
+         * @param {Results} results
+         * @param {string} fullId
+         * @param {integer} id
+         * @param {integer} index
+         * @param {integer} lev
+         */
+        function addIntoResults(results, fullId, id, index, lev) {
+            if (lev === 0 || (!parsedQuery.literalSearch && lev <= MAX_LEV_DISTANCE)) {
+                if (results[fullId] !== undefined) {
+                    const result = results[fullId];
+                    if (result.dontValidate || result.lev <= lev) {
+                        return;
+                    }
+                }
+                results[fullId] = {
+                    id: id,
+                    index: index,
+                    dontValidate: parsedQuery.literalSearch,
+                    lev: lev,
+                };
+            }
+        }
+
+        /**
+         * This function is called in case the query is only one element (with or without generics).
+         * This element will be compared to arguments' and returned values' items and also to items.
+         *
+         * Other important thing to note: since there is only one element, we use levenshtein
+         * distance for name comparisons.
+         *
+         * @param {Row} row
+         * @param {integer} pos              - Position in the `searchIndex`.
+         * @param {QueryElement} elem        - The element from the parsed query.
+         * @param {Results} results_others   - Unqualified results (not in arguments nor in
+         *                                     returned values).
+         * @param {Results} results_in_args  - Matching arguments results.
+         * @param {Results} results_returned - Matching returned arguments results.
+         */
+        function handleSingleArg(
+            row,
+            pos,
+            elem,
+            results_others,
+            results_in_args,
+            results_returned
+        ) {
+            if (!row || (filterCrates !== null && row.crate !== filterCrates)) {
+                return;
+            }
+            let lev, lev_add = 0, index = -1;
+            const fullId = row.id;
+
+            const in_args = findArg(row, elem, parsedQuery.typeFilter);
+            const returned = checkReturned(row, elem, parsedQuery.typeFilter);
+
+            addIntoResults(results_in_args, fullId, pos, index, in_args);
+            addIntoResults(results_returned, fullId, pos, index, returned);
+
+            if (!typePassesFilter(parsedQuery.typeFilter, row.ty)) {
+                return;
+            }
+            const searchWord = searchWords[pos];
+
+            if (parsedQuery.literalSearch) {
+                if (searchWord === elem.name) {
+                    addIntoResults(results_others, fullId, pos, -1, 0);
+                }
+                return;
+            }
+
+            // No need to check anything else if it's a "pure" generics search.
+            if (elem.name.length === 0) {
+                if (row.type !== null) {
+                    lev = checkGenerics(row.type, elem, MAX_LEV_DISTANCE + 1);
+                    addIntoResults(results_others, fullId, pos, index, lev);
+                }
+                return;
+            }
+
+            if (elem.fullPath.length > 1) {
+                lev = checkPath(elem.pathWithoutLast, row);
+                if (lev > MAX_LEV_DISTANCE || (parsedQuery.literalSearch && lev !== 0)) {
+                    return;
+                } else if (lev > 0) {
+                    lev_add = lev / 10;
+                }
+            }
+
+            if (searchWord.indexOf(elem.pathLast) > -1 ||
+                row.normalizedName.indexOf(elem.pathLast) > -1
+            ) {
+                index = row.normalizedName.indexOf(elem.pathLast);
+            }
+            lev = levenshtein(searchWord, elem.pathLast);
+            if (lev > 0 && elem.pathLast.length > 2 && searchWord.indexOf(elem.pathLast) > -1) {
+                if (elem.pathLast.length < 6) {
+                    lev = 1;
+                } else {
+                    lev = 0;
+                }
+            }
+            lev += lev_add;
+            if (lev > MAX_LEV_DISTANCE) {
+                return;
+            } else if (index !== -1 && elem.fullPath.length < 2) {
+                lev -= 1;
+            }
+            if (lev < 0) {
+                lev = 0;
+            }
+            addIntoResults(results_others, fullId, pos, index, lev);
+        }
+
+        /**
+         * This function is called in case the query has more than one element. In this case, it'll
+         * try to match the items which validates all the elements. For `aa -> bb` will look for
+         * functions which have a parameter `aa` and has `bb` in its returned values.
+         *
+         * @param {Row} row
+         * @param {integer} pos      - Position in the `searchIndex`.
+         * @param {Object} results
+         */
+        function handleArgs(row, pos, results) {
+            if (!row || (filterCrates !== null && row.crate !== filterCrates)) {
+                return;
+            }
+
+            let totalLev = 0;
+            let nbLev = 0;
+
+            // If the result is too "bad", we return false and it ends this search.
+            function checkArgs(elems, callback) {
+                for (const elem of elems) {
+                    // There is more than one parameter to the query so all checks should be "exact"
+                    const lev = callback(row, elem, NO_TYPE_FILTER);
+                    if (lev <= 1) {
+                        nbLev += 1;
+                        totalLev += lev;
+                    } else {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            if (!checkArgs(parsedQuery.elems, findArg)) {
+                return;
+            }
+            if (!checkArgs(parsedQuery.returned, checkReturned)) {
+                return;
+            }
+
+            if (nbLev === 0) {
+                return;
+            }
+            const lev = Math.round(totalLev / nbLev);
+            addIntoResults(results, row.id, pos, 0, lev);
+        }
+
+        function innerRunQuery() {
+            let elem, i, nSearchWords, in_returned, row;
+
+            if (parsedQuery.foundElems === 1) {
+                if (parsedQuery.elems.length === 1) {
+                    elem = parsedQuery.elems[0];
+                    for (i = 0, nSearchWords = searchWords.length; i < nSearchWords; ++i) {
+                        // It means we want to check for this element everywhere (in names, args and
+                        // returned).
+                        handleSingleArg(
+                            searchIndex[i],
+                            i,
+                            elem,
+                            results_others,
+                            results_in_args,
+                            results_returned
+                        );
+                    }
+                } else if (parsedQuery.returned.length === 1) {
+                    // We received one returned argument to check, so looking into returned values.
+                    elem = parsedQuery.returned[0];
+                    for (i = 0, nSearchWords = searchWords.length; i < nSearchWords; ++i) {
+                        row = searchIndex[i];
+                        in_returned = checkReturned(row, elem, parsedQuery.typeFilter);
+                        addIntoResults(results_others, row.id, i, -1, in_returned);
+                    }
+                }
+            } else if (parsedQuery.foundElems > 0) {
+                for (i = 0, nSearchWords = searchWords.length; i < nSearchWords; ++i) {
+                    handleArgs(searchIndex[i], i, results_others);
+                }
+            }
+        }
+
+        if (parsedQuery.error === null) {
+            innerRunQuery();
+        }
+
+        const ret = createQueryResults(
+            sortResults(results_in_args, true, currentCrate),
+            sortResults(results_returned, true, currentCrate),
+            sortResults(results_others, false, currentCrate),
+            parsedQuery);
+        handleAliases(ret, parsedQuery.original.replace(/"/g, ""), filterCrates, currentCrate);
+        if (parsedQuery.error !== null && ret.others.length !== 0) {
+            // It means some doc aliases were found so let's "remove" the error!
+            ret.query.error = null;
+        }
+        return ret;
+    }
+
+    /**
+     * Validate performs the following boolean logic. For example:
+     * "File::open" will give IF A PARENT EXISTS => ("file" && "open")
+     * exists in (name || path || parent) OR => ("file" && "open") exists in
+     * (name || path )
+     *
+     * This could be written functionally, but I wanted to minimise
+     * functions on stack.
+     *
+     * @param  {string} name   - The name of the result
+     * @param  {string} path   - The path of the result
+     * @param  {string} keys   - The keys to be used (["file", "open"])
+     * @param  {Object} parent - The parent of the result
+     *
+     * @return {boolean}       - Whether the result is valid or not
+     */
+    function validateResult(name, path, keys, parent) {
+        if (!keys || !keys.length) {
+            return true;
+        }
+        for (const key of keys) {
+            // each check is for validation so we negate the conditions and invalidate
+            if (!(
+                // check for an exact name match
+                name.indexOf(key) > -1 ||
+                // then an exact path match
+                path.indexOf(key) > -1 ||
+                // next if there is a parent, check for exact parent match
+                (parent !== undefined && parent.name !== undefined &&
+                    parent.name.toLowerCase().indexOf(key) > -1) ||
+                // lastly check to see if the name was a levenshtein match
+                levenshtein(name, key) <= MAX_LEV_DISTANCE)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    function nextTab(direction) {
+        const next = (searchState.currentTab + direction + 3) % searchState.focusedByTab.length;
+        searchState.focusedByTab[searchState.currentTab] = document.activeElement;
+        printTab(next);
+        focusSearchResult();
+    }
+
+    // Focus the first search result on the active tab, or the result that
+    // was focused last time this tab was active.
+    function focusSearchResult() {
+        const target = searchState.focusedByTab[searchState.currentTab] ||
+            document.querySelectorAll(".search-results.active a").item(0) ||
+            document.querySelectorAll("#titles > button").item(searchState.currentTab);
+        if (target) {
+            target.focus();
+        }
+    }
+
+    function buildHrefAndPath(item) {
+        let displayPath;
+        let href;
+        const type = itemTypes[item.ty];
+        const name = item.name;
+        let path = item.path;
+
+        if (type === "mod") {
+            displayPath = path + "::";
+            href = ROOT_PATH + path.replace(/::/g, "/") + "/" +
+                name + "/index.html";
+        } else if (type === "import") {
+            displayPath = item.path + "::";
+            href = ROOT_PATH + item.path.replace(/::/g, "/") + "/index.html#reexport." + name;
+        } else if (type === "primitive" || type === "keyword") {
+            displayPath = "";
+            href = ROOT_PATH + path.replace(/::/g, "/") +
+                "/" + type + "." + name + ".html";
+        } else if (type === "externcrate") {
+            displayPath = "";
+            href = ROOT_PATH + name + "/index.html";
+        } else if (item.parent !== undefined) {
+            const myparent = item.parent;
+            let anchor = "#" + type + "." + name;
+            const parentType = itemTypes[myparent.ty];
+            let pageType = parentType;
+            let pageName = myparent.name;
+
+            if (parentType === "primitive") {
+                displayPath = myparent.name + "::";
+            } else if (type === "structfield" && parentType === "variant") {
+                // Structfields belonging to variants are special: the
+                // final path element is the enum name.
+                const enumNameIdx = item.path.lastIndexOf("::");
+                const enumName = item.path.substr(enumNameIdx + 2);
+                path = item.path.substr(0, enumNameIdx);
+                displayPath = path + "::" + enumName + "::" + myparent.name + "::";
+                anchor = "#variant." + myparent.name + ".field." + name;
+                pageType = "enum";
+                pageName = enumName;
+            } else {
+                displayPath = path + "::" + myparent.name + "::";
+            }
+            href = ROOT_PATH + path.replace(/::/g, "/") +
+                "/" + pageType +
+                "." + pageName +
+                ".html" + anchor;
+        } else {
+            displayPath = item.path + "::";
+            href = ROOT_PATH + item.path.replace(/::/g, "/") +
+                "/" + type + "." + name + ".html";
+        }
+        return [displayPath, href];
+    }
+
+    function escape(content) {
+        const h1 = document.createElement("h1");
+        h1.textContent = content;
+        return h1.innerHTML;
+    }
+
+    function pathSplitter(path) {
+        const tmp = "<span>" + path.replace(/::/g, "::</span><span>");
+        if (tmp.endsWith("<span>")) {
+            return tmp.slice(0, tmp.length - 6);
+        }
+        return tmp;
+    }
+
+    /**
+     * Render a set of search results for a single tab.
+     * @param {Array<?>}    array   - The search results for this tab
+     * @param {ParsedQuery} query
+     * @param {boolean}     display - True if this is the active tab
+     */
+    function addTab(array, query, display) {
+        let extraClass = "";
+        if (display === true) {
+            extraClass = " active";
+        }
+
+        const output = document.createElement("div");
+        let length = 0;
+        if (array.length > 0) {
+            output.className = "search-results " + extraClass;
+
+            array.forEach(item => {
+                const name = item.name;
+                const type = itemTypes[item.ty];
+
+                length += 1;
+
+                let extra = "";
+                if (type === "primitive") {
+                    extra = " <i>(primitive type)</i>";
+                } else if (type === "keyword") {
+                    extra = " <i>(keyword)</i>";
+                }
+
+                const link = document.createElement("a");
+                link.className = "result-" + type;
+                link.href = item.href;
+
+                const wrapper = document.createElement("div");
+                const resultName = document.createElement("div");
+                resultName.className = "result-name";
+
+                if (item.is_alias) {
+                    const alias = document.createElement("span");
+                    alias.className = "alias";
+
+                    const bold = document.createElement("b");
+                    bold.innerText = item.alias;
+                    alias.appendChild(bold);
+
+                    alias.insertAdjacentHTML(
+                        "beforeend",
+                        "<span class=\"grey\"><i>&nbsp;- see&nbsp;</i></span>");
+
+                    resultName.appendChild(alias);
+                }
+                resultName.insertAdjacentHTML(
+                    "beforeend",
+                    item.displayPath + "<span class=\"" + type + "\">" + name + extra + "</span>");
+                wrapper.appendChild(resultName);
+
+                const description = document.createElement("div");
+                description.className = "desc";
+                const spanDesc = document.createElement("span");
+                spanDesc.insertAdjacentHTML("beforeend", item.desc);
+
+                description.appendChild(spanDesc);
+                wrapper.appendChild(description);
+                link.appendChild(wrapper);
+                output.appendChild(link);
+            });
+        } else if (query.error === null) {
+            output.className = "search-failed" + extraClass;
+            output.innerHTML = "No results :(<br/>" +
+                "Try on <a href=\"https://duckduckgo.com/?q=" +
+                encodeURIComponent("rust " + query.userQuery) +
+                "\">DuckDuckGo</a>?<br/><br/>" +
+                "Or try looking in one of these:<ul><li>The <a " +
+                "href=\"https://doc.rust-lang.org/reference/index.html\">Rust Reference</a> " +
+                " for technical details about the language.</li><li><a " +
+                "href=\"https://doc.rust-lang.org/rust-by-example/index.html\">Rust By " +
+                "Example</a> for expository code examples.</a></li><li>The <a " +
+                "href=\"https://doc.rust-lang.org/book/index.html\">Rust Book</a> for " +
+                "introductions to language features and the language itself.</li><li><a " +
+                "href=\"https://docs.rs\">Docs.rs</a> for documentation of crates released on" +
+                " <a href=\"https://crates.io/\">crates.io</a>.</li></ul>";
+        }
+        return [output, length];
+    }
+
+    function makeTabHeader(tabNb, text, nbElems) {
+        if (searchState.currentTab === tabNb) {
+            return "<button class=\"selected\">" + text +
+                   " <div class=\"count\">(" + nbElems + ")</div></button>";
+        }
+        return "<button>" + text + " <div class=\"count\">(" + nbElems + ")</div></button>";
+    }
+
+    /**
+     * @param {ResultsTable} results
+     * @param {boolean} go_to_first
+     * @param {string} filterCrates
+     */
+    function showResults(results, go_to_first, filterCrates) {
+        const search = searchState.outputElement();
+        if (go_to_first || (results.others.length === 1
+            && getSettingValue("go-to-only-result") === "true"
+            // By default, the search DOM element is "empty" (meaning it has no children not
+            // text content). Once a search has been run, it won't be empty, even if you press
+            // ESC or empty the search input (which also "cancels" the search).
+            && (!search.firstChild || search.firstChild.innerText !== searchState.loadingText))
+        ) {
+            const elem = document.createElement("a");
+            elem.href = results.others[0].href;
+            removeClass(elem, "active");
+            // For firefox, we need the element to be in the DOM so it can be clicked.
+            document.body.appendChild(elem);
+            elem.click();
+            return;
+        }
+        if (results.query === undefined) {
+            results.query = parseQuery(searchState.input.value);
+        }
+
+        currentResults = results.query.userQuery;
+
+        const ret_others = addTab(results.others, results.query, true);
+        const ret_in_args = addTab(results.in_args, results.query, false);
+        const ret_returned = addTab(results.returned, results.query, false);
+
+        // Navigate to the relevant tab if the current tab is empty, like in case users search
+        // for "-> String". If they had selected another tab previously, they have to click on
+        // it again.
+        let currentTab = searchState.currentTab;
+        if ((currentTab === 0 && ret_others[1] === 0) ||
+                (currentTab === 1 && ret_in_args[1] === 0) ||
+                (currentTab === 2 && ret_returned[1] === 0)) {
+            if (ret_others[1] !== 0) {
+                currentTab = 0;
+            } else if (ret_in_args[1] !== 0) {
+                currentTab = 1;
+            } else if (ret_returned[1] !== 0) {
+                currentTab = 2;
+            }
+        }
+
+        let crates = "";
+        const crates_list = Object.keys(rawSearchIndex);
+        if (crates_list.length > 1) {
+            crates = " in <select id=\"crate-search\"><option value=\"All crates\">" +
+                "All crates</option>";
+            for (const c of crates_list) {
+                crates += `<option value="${c}" ${c === filterCrates && "selected"}>${c}</option>`;
+            }
+            crates += "</select>";
+        }
+
+        let typeFilter = "";
+        if (results.query.typeFilter !== NO_TYPE_FILTER) {
+            typeFilter = " (type: " + escape(itemTypes[results.query.typeFilter]) + ")";
+        }
+
+        let output = "<div id=\"search-settings\">" +
+            `<h1 class="search-results-title">Results for ${escape(results.query.userQuery)}` +
+            `${typeFilter}</h1>${crates}</div>`;
+        if (results.query.error !== null) {
+            output += `<h3>Query parser error: "${results.query.error}".</h3>`;
+            output += "<div id=\"titles\">" +
+                makeTabHeader(0, "In Names", ret_others[1]) +
+                "</div>";
+            currentTab = 0;
+        } else if (results.query.foundElems <= 1 && results.query.returned.length === 0) {
+            output += "<div id=\"titles\">" +
+                makeTabHeader(0, "In Names", ret_others[1]) +
+                makeTabHeader(1, "In Parameters", ret_in_args[1]) +
+                makeTabHeader(2, "In Return Types", ret_returned[1]) +
+                "</div>";
+        } else {
+            const signatureTabTitle =
+                results.query.elems.length === 0 ? "In Function Return Types" :
+                results.query.returned.length === 0 ? "In Function Parameters" :
+                "In Function Signatures";
+            output += "<div id=\"titles\">" +
+                makeTabHeader(0, signatureTabTitle, ret_others[1]) +
+                "</div>";
+            currentTab = 0;
+        }
+
+        const resultsElem = document.createElement("div");
+        resultsElem.id = "results";
+        resultsElem.appendChild(ret_others[0]);
+        resultsElem.appendChild(ret_in_args[0]);
+        resultsElem.appendChild(ret_returned[0]);
+
+        search.innerHTML = output;
+        const crateSearch = document.getElementById("crate-search");
+        if (crateSearch) {
+            crateSearch.addEventListener("input", updateCrate);
+        }
+        search.appendChild(resultsElem);
+        // Reset focused elements.
+        searchState.showResults(search);
+        const elems = document.getElementById("titles").childNodes;
+        searchState.focusedByTab = [];
+        let i = 0;
+        for (const elem of elems) {
+            const j = i;
+            elem.onclick = () => printTab(j);
+            searchState.focusedByTab.push(null);
+            i += 1;
+        }
+        printTab(currentTab);
+    }
+
+    /**
+     * Perform a search based on the current state of the search input element
+     * and display the results.
+     * @param {Event}   [e]       - The event that triggered this search, if any
+     * @param {boolean} [forced]
+     */
+    function search(e, forced) {
+        const params = searchState.getQueryStringParams();
+        const query = parseQuery(searchState.input.value.trim());
+
+        if (e) {
+            e.preventDefault();
+        }
+
+        if (!forced && query.userQuery === currentResults) {
+            if (query.userQuery.length > 0) {
+                putBackSearch();
+            }
+            return;
+        }
+
+        let filterCrates = getFilterCrates();
+
+        // In case we have no information about the saved crate and there is a URL query parameter,
+        // we override it with the URL query parameter.
+        if (filterCrates === null && params["filter-crate"] !== undefined) {
+            filterCrates = params["filter-crate"];
+        }
+
+        // Update document title to maintain a meaningful browser history
+        searchState.title = "Results for " + query.original + " - Rust";
+
+        // Because searching is incremental by character, only the most
+        // recent search query is added to the browser history.
+        if (browserSupportsHistoryApi()) {
+            const newURL = buildUrl(query.original, filterCrates);
+
+            if (!history.state && !params.search) {
+                history.pushState(null, "", newURL);
+            } else {
+                history.replaceState(null, "", newURL);
+            }
+        }
+
+        showResults(
+            execQuery(query, searchWords, filterCrates, window.currentCrate),
+            params.go_to_first,
+            filterCrates);
+    }
+
+    /**
+     * Convert a list of RawFunctionType / ID to object-based FunctionType.
+     *
+     * Crates often have lots of functions in them, and it's common to have a large number of
+     * functions that operate on a small set of data types, so the search index compresses them
+     * by encoding function parameter and return types as indexes into an array of names.
+     *
+     * Even when a general-purpose compression algorithm is used, this is still a win. I checked.
+     * https://github.com/rust-lang/rust/pull/98475#issue-1284395985
+     *
+     * The format for individual function types is encoded in
+     * librustdoc/html/render/mod.rs: impl Serialize for RenderType
+     *
+     * @param {null|Array<RawFunctionType>} types
+     * @param {Array<{name: string, ty: number}>} lowercasePaths
+     *
+     * @return {Array<FunctionSearchType>}
+     */
+    function buildItemSearchTypeAll(types, lowercasePaths) {
+        const PATH_INDEX_DATA = 0;
+        const GENERICS_DATA = 1;
+        return types.map(type => {
+            let pathIndex, generics;
+            if (typeof type === "number") {
+                pathIndex = type;
+                generics = [];
+            } else {
+                pathIndex = type[PATH_INDEX_DATA];
+                generics = buildItemSearchTypeAll(type[GENERICS_DATA], lowercasePaths);
+            }
+            return {
+                // `0` is used as a sentinel because it's fewer bytes than `null`
+                name: pathIndex === 0 ? null : lowercasePaths[pathIndex - 1].name,
+                ty: pathIndex === 0 ? null : lowercasePaths[pathIndex - 1].ty,
+                generics: generics,
+            };
+        });
+    }
+
+    /**
+     * Convert from RawFunctionSearchType to FunctionSearchType.
+     *
+     * Crates often have lots of functions in them, and function signatures are sometimes complex,
+     * so rustdoc uses a pretty tight encoding for them. This function converts it to a simpler,
+     * object-based encoding so that the actual search code is more readable and easier to debug.
+     *
+     * The raw function search type format is generated using serde in
+     * librustdoc/html/render/mod.rs: impl Serialize for IndexItemFunctionType
+     *
+     * @param {RawFunctionSearchType} functionSearchType
+     * @param {Array<{name: string, ty: number}>} lowercasePaths
+     *
+     * @return {null|FunctionSearchType}
+     */
+    function buildFunctionSearchType(functionSearchType, lowercasePaths) {
+        const INPUTS_DATA = 0;
+        const OUTPUT_DATA = 1;
+        // `0` is used as a sentinel because it's fewer bytes than `null`
+        if (functionSearchType === 0) {
+            return null;
+        }
+        let inputs, output;
+        if (typeof functionSearchType[INPUTS_DATA] === "number") {
+            const pathIndex = functionSearchType[INPUTS_DATA];
+            inputs = [{
+                name: pathIndex === 0 ? null : lowercasePaths[pathIndex - 1].name,
+                ty: pathIndex === 0 ? null : lowercasePaths[pathIndex - 1].ty,
+                generics: [],
+            }];
+        } else {
+            inputs = buildItemSearchTypeAll(functionSearchType[INPUTS_DATA], lowercasePaths);
+        }
+        if (functionSearchType.length > 1) {
+            if (typeof functionSearchType[OUTPUT_DATA] === "number") {
+                const pathIndex = functionSearchType[OUTPUT_DATA];
+                output = [{
+                    name: pathIndex === 0 ? null : lowercasePaths[pathIndex - 1].name,
+                    ty: pathIndex === 0 ? null : lowercasePaths[pathIndex - 1].ty,
+                    generics: [],
+                }];
+            } else {
+                output = buildItemSearchTypeAll(functionSearchType[OUTPUT_DATA], lowercasePaths);
+            }
+        } else {
+            output = [];
+        }
+        return {
+            inputs, output,
+        };
+    }
+
+    function buildIndex(rawSearchIndex) {
+        searchIndex = [];
+        /**
+         * @type {Array<string>}
+         */
+        const searchWords = [];
+        let i, word;
+        let currentIndex = 0;
+        let id = 0;
+
+        for (const crate in rawSearchIndex) {
+            if (!hasOwnPropertyRustdoc(rawSearchIndex, crate)) {
+                continue;
+            }
+
+            let crateSize = 0;
+
+            /**
+             * The raw search data for a given crate. `n`, `t`, `d`, and `q`, `i`, and `f`
+             * are arrays with the same length. n[i] contains the name of an item.
+             * t[i] contains the type of that item (as a small integer that represents an
+             * offset in `itemTypes`). d[i] contains the description of that item.
+             *
+             * q[i] contains the full path of the item, or an empty string indicating
+             * "same as q[i-1]".
+             *
+             * i[i] contains an item's parent, usually a module. For compactness,
+             * it is a set of indexes into the `p` array.
+             *
+             * f[i] contains function signatures, or `0` if the item isn't a function.
+             * Functions are themselves encoded as arrays. The first item is a list of
+             * types representing the function's inputs, and the second list item is a list
+             * of types representing the function's output. Tuples are flattened.
+             * Types are also represented as arrays; the first item is an index into the `p`
+             * array, while the second is a list of types representing any generic parameters.
+             *
+             * `a` defines aliases with an Array of pairs: [name, offset], where `offset`
+             * points into the n/t/d/q/i/f arrays.
+             *
+             * `doc` contains the description of the crate.
+             *
+             * `p` is a list of path/type pairs. It is used for parents and function parameters.
+             *
+             * @type {{
+             *   doc: string,
+             *   a: Object,
+             *   n: Array<string>,
+             *   t: Array<Number>,
+             *   d: Array<string>,
+             *   q: Array<string>,
+             *   i: Array<Number>,
+             *   f: Array<RawFunctionSearchType>,
+             *   p: Array<Object>,
+             * }}
+             */
+            const crateCorpus = rawSearchIndex[crate];
+
+            searchWords.push(crate);
+            // This object should have exactly the same set of fields as the "row"
+            // object defined below. Your JavaScript runtime will thank you.
+            // https://mathiasbynens.be/notes/shapes-ics
+            const crateRow = {
+                crate: crate,
+                ty: 1, // == ExternCrate
+                name: crate,
+                path: "",
+                desc: crateCorpus.doc,
+                parent: undefined,
+                type: null,
+                id: id,
+                normalizedName: crate.indexOf("_") === -1 ? crate : crate.replace(/_/g, ""),
+            };
+            id += 1;
+            searchIndex.push(crateRow);
+            currentIndex += 1;
+
+            // an array of (Number) item types
+            const itemTypes = crateCorpus.t;
+            // an array of (String) item names
+            const itemNames = crateCorpus.n;
+            // an array of (String) full paths (or empty string for previous path)
+            const itemPaths = crateCorpus.q;
+            // an array of (String) descriptions
+            const itemDescs = crateCorpus.d;
+            // an array of (Number) the parent path index + 1 to `paths`, or 0 if none
+            const itemParentIdxs = crateCorpus.i;
+            // an array of (Object | null) the type of the function, if any
+            const itemFunctionSearchTypes = crateCorpus.f;
+            // an array of [(Number) item type,
+            //              (String) name]
+            const paths = crateCorpus.p;
+            // an array of [(String) alias name
+            //             [Number] index to items]
+            const aliases = crateCorpus.a;
+
+            // an array of [{name: String, ty: Number}]
+            const lowercasePaths = [];
+
+            // convert `rawPaths` entries into object form
+            // generate normalizedPaths for function search mode
+            let len = paths.length;
+            for (i = 0; i < len; ++i) {
+                lowercasePaths.push({ty: paths[i][0], name: paths[i][1].toLowerCase()});
+                paths[i] = {ty: paths[i][0], name: paths[i][1]};
+            }
+
+            // convert `item*` into an object form, and construct word indices.
+            //
+            // before any analysis is performed lets gather the search terms to
+            // search against apart from the rest of the data.  This is a quick
+            // operation that is cached for the life of the page state so that
+            // all other search operations have access to this cached data for
+            // faster analysis operations
+            len = itemTypes.length;
+            let lastPath = "";
+            for (i = 0; i < len; ++i) {
+                // This object should have exactly the same set of fields as the "crateRow"
+                // object defined above.
+                if (typeof itemNames[i] === "string") {
+                    word = itemNames[i].toLowerCase();
+                    searchWords.push(word);
+                } else {
+                    word = "";
+                    searchWords.push("");
+                }
+                const row = {
+                    crate: crate,
+                    ty: itemTypes[i],
+                    name: itemNames[i],
+                    path: itemPaths[i] ? itemPaths[i] : lastPath,
+                    desc: itemDescs[i],
+                    parent: itemParentIdxs[i] > 0 ? paths[itemParentIdxs[i] - 1] : undefined,
+                    type: buildFunctionSearchType(itemFunctionSearchTypes[i], lowercasePaths),
+                    id: id,
+                    normalizedName: word.indexOf("_") === -1 ? word : word.replace(/_/g, ""),
+                };
+                id += 1;
+                searchIndex.push(row);
+                lastPath = row.path;
+                crateSize += 1;
+            }
+
+            if (aliases) {
+                ALIASES[crate] = Object.create(null);
+                for (const alias_name in aliases) {
+                    if (!hasOwnPropertyRustdoc(aliases, alias_name)) {
+                        continue;
+                    }
+
+                    if (!hasOwnPropertyRustdoc(ALIASES[crate], alias_name)) {
+                        ALIASES[crate][alias_name] = [];
+                    }
+                    for (const local_alias of aliases[alias_name]) {
+                        ALIASES[crate][alias_name].push(local_alias + currentIndex);
+                    }
+                }
+            }
+            currentIndex += crateSize;
+        }
+        return searchWords;
+    }
+
+    /**
+     * Callback for when the search form is submitted.
+     * @param {Event} [e] - The event that triggered this call, if any
+     */
+    function onSearchSubmit(e) {
+        e.preventDefault();
+        searchState.clearInputTimeout();
+        search();
+    }
+
+    function putBackSearch() {
+        const search_input = searchState.input;
+        if (!searchState.input) {
+            return;
+        }
+        if (search_input.value !== "" && !searchState.isDisplayed()) {
+            searchState.showResults();
+            if (browserSupportsHistoryApi()) {
+                history.replaceState(null, "",
+                    buildUrl(search_input.value, getFilterCrates()));
+            }
+            document.title = searchState.title;
+        }
+    }
+
+    function registerSearchEvents() {
+        const params = searchState.getQueryStringParams();
+
+        // Populate search bar with query string search term when provided,
+        // but only if the input bar is empty. This avoid the obnoxious issue
+        // where you start trying to do a search, and the index loads, and
+        // suddenly your search is gone!
+        if (searchState.input.value === "") {
+            searchState.input.value = params.search || "";
+        }
+
+        const searchAfter500ms = () => {
+            searchState.clearInputTimeout();
+            if (searchState.input.value.length === 0) {
+                if (browserSupportsHistoryApi()) {
+                    history.replaceState(null, window.currentCrate + " - Rust",
+                        getNakedUrl() + window.location.hash);
+                }
+                searchState.hideResults();
+            } else {
+                searchState.timeout = setTimeout(search, 500);
+            }
+        };
+        searchState.input.onkeyup = searchAfter500ms;
+        searchState.input.oninput = searchAfter500ms;
+        document.getElementsByClassName("search-form")[0].onsubmit = onSearchSubmit;
+        searchState.input.onchange = e => {
+            if (e.target !== document.activeElement) {
+                // To prevent doing anything when it's from a blur event.
+                return;
+            }
+            // Do NOT e.preventDefault() here. It will prevent pasting.
+            searchState.clearInputTimeout();
+            // zero-timeout necessary here because at the time of event handler execution the
+            // pasted content is not in the input field yet. Shouldn’t make any difference for
+            // change, though.
+            setTimeout(search, 0);
+        };
+        searchState.input.onpaste = searchState.input.onchange;
+
+        searchState.outputElement().addEventListener("keydown", e => {
+            // We only handle unmodified keystrokes here. We don't want to interfere with,
+            // for instance, alt-left and alt-right for history navigation.
+            if (e.altKey || e.ctrlKey || e.shiftKey || e.metaKey) {
+                return;
+            }
+            // up and down arrow select next/previous search result, or the
+            // search box if we're already at the top.
+            if (e.which === 38) { // up
+                const previous = document.activeElement.previousElementSibling;
+                if (previous) {
+                    previous.focus();
+                } else {
+                    searchState.focus();
+                }
+                e.preventDefault();
+            } else if (e.which === 40) { // down
+                const next = document.activeElement.nextElementSibling;
+                if (next) {
+                    next.focus();
+                }
+                const rect = document.activeElement.getBoundingClientRect();
+                if (window.innerHeight - rect.bottom < rect.height) {
+                    window.scrollBy(0, rect.height);
+                }
+                e.preventDefault();
+            } else if (e.which === 37) { // left
+                nextTab(-1);
+                e.preventDefault();
+            } else if (e.which === 39) { // right
+                nextTab(1);
+                e.preventDefault();
+            }
+        });
+
+        searchState.input.addEventListener("keydown", e => {
+            if (e.which === 40) { // down
+                focusSearchResult();
+                e.preventDefault();
+            }
+        });
+
+        searchState.input.addEventListener("focus", () => {
+            putBackSearch();
+        });
+
+        searchState.input.addEventListener("blur", () => {
+            searchState.input.placeholder = searchState.input.origPlaceholder;
+        });
+
+        // Push and pop states are used to add search results to the browser
+        // history.
+        if (browserSupportsHistoryApi()) {
+            // Store the previous <title> so we can revert back to it later.
+            const previousTitle = document.title;
+
+            window.addEventListener("popstate", e => {
+                const params = searchState.getQueryStringParams();
+                // Revert to the previous title manually since the History
+                // API ignores the title parameter.
+                document.title = previousTitle;
+                // When browsing forward to search results the previous
+                // search will be repeated, so the currentResults are
+                // cleared to ensure the search is successful.
+                currentResults = null;
+                // Synchronize search bar with query string state and
+                // perform the search. This will empty the bar if there's
+                // nothing there, which lets you really go back to a
+                // previous state with nothing in the bar.
+                if (params.search && params.search.length > 0) {
+                    searchState.input.value = params.search;
+                    // Some browsers fire "onpopstate" for every page load
+                    // (Chrome), while others fire the event only when actually
+                    // popping a state (Firefox), which is why search() is
+                    // called both here and at the end of the startSearch()
+                    // function.
+                    search(e);
+                } else {
+                    searchState.input.value = "";
+                    // When browsing back from search results the main page
+                    // visibility must be reset.
+                    searchState.hideResults();
+                }
+            });
+        }
+
+        // This is required in firefox to avoid this problem: Navigating to a search result
+        // with the keyboard, hitting enter, and then hitting back would take you back to
+        // the doc page, rather than the search that should overlay it.
+        // This was an interaction between the back-forward cache and our handlers
+        // that try to sync state between the URL and the search input. To work around it,
+        // do a small amount of re-init on page show.
+        window.onpageshow = () => {
+            const qSearch = searchState.getQueryStringParams().search;
+            if (searchState.input.value === "" && qSearch) {
+                searchState.input.value = qSearch;
+            }
+            search();
+        };
+    }
+
+    function updateCrate(ev) {
+        if (ev.target.value === "All crates") {
+            // If we don't remove it from the URL, it'll be picked up again by the search.
+            const params = searchState.getQueryStringParams();
+            const query = searchState.input.value.trim();
+            if (!history.state && !params.search) {
+                history.pushState(null, "", buildUrl(query, null));
+            } else {
+                history.replaceState(null, "", buildUrl(query, null));
+            }
+        }
+        // In case you "cut" the entry from the search input, then change the crate filter
+        // before paste back the previous search, you get the old search results without
+        // the filter. To prevent this, we need to remove the previous results.
+        currentResults = null;
+        search(undefined, true);
+    }
+
+    /**
+     *  @type {Array<string>}
+     */
+    const searchWords = buildIndex(rawSearchIndex);
+    if (typeof window !== "undefined") {
+        registerSearchEvents();
+        // If there's a search term in the URL, execute the search now.
+        if (window.searchState.getQueryStringParams().search) {
+            search();
+        }
+    }
+
+    if (typeof exports !== "undefined") {
+        exports.initSearch = initSearch;
+        exports.execQuery = execQuery;
+        exports.parseQuery = parseQuery;
+    }
+    return searchWords;
+}
+
+if (typeof window !== "undefined") {
+    window.initSearch = initSearch;
+    if (window.searchIndex !== undefined) {
+        initSearch(window.searchIndex);
+    }
+} else {
+    // Running in Node, not a browser. Run initSearch just to produce the
+    // exports.
+    initSearch({});
+}
+
+
+})();
diff --git a/src/librustdoc/html/static/js/settings.js b/src/librustdoc/html/static/js/settings.js
new file mode 100644
index 000000000..797b931af
--- /dev/null
+++ b/src/librustdoc/html/static/js/settings.js
@@ -0,0 +1,272 @@
+// Local js definitions:
+/* global getSettingValue, getVirtualKey, updateLocalStorage, updateSystemTheme */
+/* global addClass, removeClass, onEach, onEachLazy, blurHandler, elemIsInParent */
+/* global MAIN_ID, getVar, getSettingsButton */
+
+"use strict";
+
+(function() {
+    const isSettingsPage = window.location.pathname.endsWith("/settings.html");
+
+    function changeSetting(settingName, value) {
+        updateLocalStorage(settingName, value);
+
+        switch (settingName) {
+            case "theme":
+            case "preferred-dark-theme":
+            case "preferred-light-theme":
+            case "use-system-theme":
+                updateSystemTheme();
+                updateLightAndDark();
+                break;
+        }
+    }
+
+    function handleKey(ev) {
+        // Don't interfere with browser shortcuts
+        if (ev.ctrlKey || ev.altKey || ev.metaKey) {
+            return;
+        }
+        switch (getVirtualKey(ev)) {
+            case "Enter":
+            case "Return":
+            case "Space":
+                ev.target.checked = !ev.target.checked;
+                ev.preventDefault();
+                break;
+        }
+    }
+
+    function showLightAndDark() {
+        addClass(document.getElementById("theme").parentElement, "hidden");
+        removeClass(document.getElementById("preferred-light-theme").parentElement, "hidden");
+        removeClass(document.getElementById("preferred-dark-theme").parentElement, "hidden");
+    }
+
+    function hideLightAndDark() {
+        addClass(document.getElementById("preferred-light-theme").parentElement, "hidden");
+        addClass(document.getElementById("preferred-dark-theme").parentElement, "hidden");
+        removeClass(document.getElementById("theme").parentElement, "hidden");
+    }
+
+    function updateLightAndDark() {
+        if (getSettingValue("use-system-theme") !== "false") {
+            showLightAndDark();
+        } else {
+            hideLightAndDark();
+        }
+    }
+
+    function setEvents(settingsElement) {
+        updateLightAndDark();
+        onEachLazy(settingsElement.getElementsByClassName("slider"), elem => {
+            const toggle = elem.previousElementSibling;
+            const settingId = toggle.id;
+            const settingValue = getSettingValue(settingId);
+            if (settingValue !== null) {
+                toggle.checked = settingValue === "true";
+            }
+            toggle.onchange = function() {
+                changeSetting(this.id, this.checked);
+            };
+            toggle.onkeyup = handleKey;
+            toggle.onkeyrelease = handleKey;
+        });
+        onEachLazy(settingsElement.getElementsByClassName("select-wrapper"), elem => {
+            const select = elem.getElementsByTagName("select")[0];
+            const settingId = select.id;
+            const settingValue = getSettingValue(settingId);
+            if (settingValue !== null) {
+                select.value = settingValue;
+            }
+            select.onchange = function() {
+                changeSetting(this.id, this.value);
+            };
+        });
+        onEachLazy(settingsElement.querySelectorAll("input[type=\"radio\"]"), elem => {
+            const settingId = elem.name;
+            const settingValue = getSettingValue(settingId);
+            if (settingValue !== null && settingValue !== "null") {
+                elem.checked = settingValue === elem.value;
+            }
+            elem.addEventListener("change", ev => {
+                changeSetting(ev.target.name, ev.target.value);
+            });
+        });
+    }
+
+    /**
+     * This function builds the sections inside the "settings page". It takes a `settings` list
+     * as argument which describes each setting and how to render it. It returns a string
+     * representing the raw HTML.
+     *
+     * @param {Array<Object>} settings
+     *
+     * @return {string}
+     */
+    function buildSettingsPageSections(settings) {
+        let output = "";
+
+        for (const setting of settings) {
+            output += "<div class=\"setting-line\">";
+            const js_data_name = setting["js_name"];
+            const setting_name = setting["name"];
+
+            if (setting["options"] !== undefined) {
+                // This is a select setting.
+                output += `<div class="radio-line" id="${js_data_name}">\
+                        <span class="setting-name">${setting_name}</span>\
+                        <div class="choices">`;
+                onEach(setting["options"], option => {
+                    const checked = option === setting["default"] ? " checked" : "";
+
+                    output += `<label for="${js_data_name}-${option}" class="choice">\
+                           <input type="radio" name="${js_data_name}" \
+                                id="${js_data_name}-${option}" value="${option}"${checked}>\
+                           <span>${option}</span>\
+                         </label>`;
+                });
+                output += "</div></div>";
+            } else {
+                // This is a toggle.
+                const checked = setting["default"] === true ? " checked" : "";
+                output += `<label class="toggle">\
+                        <input type="checkbox" id="${js_data_name}"${checked}>\
+                        <span class="slider"></span>\
+                        <span class="label">${setting_name}</span>\
+                    </label>`;
+            }
+            output += "</div>";
+        }
+        return output;
+    }
+
+    /**
+     * This function builds the "settings page" and returns the generated HTML element.
+     *
+     * @return {HTMLElement}
+     */
+    function buildSettingsPage() {
+        const themes = getVar("themes").split(",");
+        const settings = [
+            {
+                "name": "Use system theme",
+                "js_name": "use-system-theme",
+                "default": true,
+            },
+            {
+                "name": "Theme",
+                "js_name": "theme",
+                "default": "light",
+                "options": themes,
+            },
+            {
+                "name": "Preferred light theme",
+                "js_name": "preferred-light-theme",
+                "default": "light",
+                "options": themes,
+            },
+            {
+                "name": "Preferred dark theme",
+                "js_name": "preferred-dark-theme",
+                "default": "dark",
+                "options": themes,
+            },
+            {
+                "name": "Auto-hide item contents for large items",
+                "js_name": "auto-hide-large-items",
+                "default": true,
+            },
+            {
+                "name": "Auto-hide item methods' documentation",
+                "js_name": "auto-hide-method-docs",
+                "default": false,
+            },
+            {
+                "name": "Auto-hide trait implementation documentation",
+                "js_name": "auto-hide-trait-implementations",
+                "default": false,
+            },
+            {
+                "name": "Directly go to item in search if there is only one result",
+                "js_name": "go-to-only-result",
+                "default": false,
+            },
+            {
+                "name": "Show line numbers on code examples",
+                "js_name": "line-numbers",
+                "default": false,
+            },
+            {
+                "name": "Disable keyboard shortcuts",
+                "js_name": "disable-shortcuts",
+                "default": false,
+            },
+        ];
+
+        // Then we build the DOM.
+        const elementKind = isSettingsPage ? "section" : "div";
+        const innerHTML = `<div class="settings">${buildSettingsPageSections(settings)}</div>`;
+        const el = document.createElement(elementKind);
+        el.id = "settings";
+        el.className = "popover";
+        el.innerHTML = innerHTML;
+
+        if (isSettingsPage) {
+            document.getElementById(MAIN_ID).appendChild(el);
+        } else {
+            el.setAttribute("tabindex", "-1");
+            getSettingsButton().appendChild(el);
+        }
+        return el;
+    }
+
+    const settingsMenu = buildSettingsPage();
+
+    function displaySettings() {
+        settingsMenu.style.display = "";
+    }
+
+    function settingsBlurHandler(event) {
+        blurHandler(event, getSettingsButton(), window.hidePopoverMenus);
+    }
+
+    if (isSettingsPage) {
+        // We replace the existing "onclick" callback to do nothing if clicked.
+        getSettingsButton().onclick = function(event) {
+            event.preventDefault();
+        };
+    } else {
+        // We replace the existing "onclick" callback.
+        const settingsButton = getSettingsButton();
+        const settingsMenu = document.getElementById("settings");
+        settingsButton.onclick = function(event) {
+            if (elemIsInParent(event.target, settingsMenu)) {
+                return;
+            }
+            event.preventDefault();
+            const shouldDisplaySettings = settingsMenu.style.display === "none";
+
+            window.hidePopoverMenus();
+            if (shouldDisplaySettings) {
+                displaySettings();
+            }
+        };
+        settingsButton.onblur = settingsBlurHandler;
+        settingsButton.querySelector("a").onblur = settingsBlurHandler;
+        onEachLazy(settingsMenu.querySelectorAll("input"), el => {
+            el.onblur = settingsBlurHandler;
+        });
+        settingsMenu.onblur = settingsBlurHandler;
+    }
+
+    // We now wait a bit for the web browser to end re-computing the DOM...
+    setTimeout(() => {
+        setEvents(settingsMenu);
+        // The setting menu is already displayed if we're on the settings page.
+        if (!isSettingsPage) {
+            displaySettings();
+        }
+        removeClass(getSettingsButton(), "rotate");
+    }, 0);
+})();
diff --git a/src/librustdoc/html/static/js/source-script.js b/src/librustdoc/html/static/js/source-script.js
new file mode 100644
index 000000000..c45d61429
--- /dev/null
+++ b/src/librustdoc/html/static/js/source-script.js
@@ -0,0 +1,241 @@
+// From rust:
+/* global sourcesIndex */
+
+// Local js definitions:
+/* global addClass, getCurrentValue, onEachLazy, removeClass, browserSupportsHistoryApi */
+/* global updateLocalStorage */
+
+"use strict";
+
+(function() {
+
+const rootPath = document.getElementById("rustdoc-vars").attributes["data-root-path"].value;
+let oldScrollPosition = 0;
+
+const NAME_OFFSET = 0;
+const DIRS_OFFSET = 1;
+const FILES_OFFSET = 2;
+
+function closeSidebarIfMobile() {
+    if (window.innerWidth < window.RUSTDOC_MOBILE_BREAKPOINT) {
+        updateLocalStorage("source-sidebar-show", "false");
+    }
+}
+
+function createDirEntry(elem, parent, fullPath, hasFoundFile) {
+    const dirEntry = document.createElement("details");
+    const summary = document.createElement("summary");
+
+    dirEntry.className = "dir-entry";
+
+    fullPath += elem[NAME_OFFSET] + "/";
+
+    summary.innerText = elem[NAME_OFFSET];
+    dirEntry.appendChild(summary);
+
+    const folders = document.createElement("div");
+    folders.className = "folders";
+    if (elem[DIRS_OFFSET]) {
+        for (const dir of elem[DIRS_OFFSET]) {
+            if (createDirEntry(dir, folders, fullPath, false)) {
+                dirEntry.open = true;
+                hasFoundFile = true;
+            }
+        }
+    }
+    dirEntry.appendChild(folders);
+
+    const files = document.createElement("div");
+    files.className = "files";
+    if (elem[FILES_OFFSET]) {
+        for (const file_text of elem[FILES_OFFSET]) {
+            const file = document.createElement("a");
+            file.innerText = file_text;
+            file.href = rootPath + "src/" + fullPath + file_text + ".html";
+            file.addEventListener("click", closeSidebarIfMobile);
+            const w = window.location.href.split("#")[0];
+            if (!hasFoundFile && w === file.href) {
+                file.className = "selected";
+                dirEntry.open = true;
+                hasFoundFile = true;
+            }
+            files.appendChild(file);
+        }
+    }
+    dirEntry.appendChild(files);
+    parent.appendChild(dirEntry);
+    return hasFoundFile;
+}
+
+function toggleSidebar() {
+    const child = this.parentNode.children[0];
+    if (child.innerText === ">") {
+        if (window.innerWidth < window.RUSTDOC_MOBILE_BREAKPOINT) {
+            // This is to keep the scroll position on mobile.
+            oldScrollPosition = window.scrollY;
+            document.body.style.position = "fixed";
+            document.body.style.top = `-${oldScrollPosition}px`;
+        }
+        addClass(document.documentElement, "source-sidebar-expanded");
+        child.innerText = "<";
+        updateLocalStorage("source-sidebar-show", "true");
+    } else {
+        if (window.innerWidth < window.RUSTDOC_MOBILE_BREAKPOINT) {
+            // This is to keep the scroll position on mobile.
+            document.body.style.position = "";
+            document.body.style.top = "";
+            // The scroll position is lost when resetting the style, hence why we store it in
+            // `oldScroll`.
+            window.scrollTo(0, oldScrollPosition);
+        }
+        removeClass(document.documentElement, "source-sidebar-expanded");
+        child.innerText = ">";
+        updateLocalStorage("source-sidebar-show", "false");
+    }
+}
+
+function createSidebarToggle() {
+    const sidebarToggle = document.createElement("div");
+    sidebarToggle.id = "sidebar-toggle";
+
+    const inner = document.createElement("button");
+
+    if (getCurrentValue("source-sidebar-show") === "true") {
+        inner.innerText = "<";
+    } else {
+        inner.innerText = ">";
+    }
+    inner.onclick = toggleSidebar;
+
+    sidebarToggle.appendChild(inner);
+    return sidebarToggle;
+}
+
+// This function is called from "source-files.js", generated in `html/render/mod.rs`.
+// eslint-disable-next-line no-unused-vars
+function createSourceSidebar() {
+    const container = document.querySelector("nav.sidebar");
+
+    const sidebarToggle = createSidebarToggle();
+    container.insertBefore(sidebarToggle, container.firstChild);
+
+    const sidebar = document.createElement("div");
+    sidebar.id = "source-sidebar";
+
+    let hasFoundFile = false;
+
+    const title = document.createElement("div");
+    title.className = "title";
+    title.innerText = "Files";
+    sidebar.appendChild(title);
+    Object.keys(sourcesIndex).forEach(key => {
+        sourcesIndex[key][NAME_OFFSET] = key;
+        hasFoundFile = createDirEntry(sourcesIndex[key], sidebar, "",
+            hasFoundFile);
+    });
+
+    container.appendChild(sidebar);
+    // Focus on the current file in the source files sidebar.
+    const selected_elem = sidebar.getElementsByClassName("selected")[0];
+    if (typeof selected_elem !== "undefined") {
+        selected_elem.focus();
+    }
+}
+
+const lineNumbersRegex = /^#?(\d+)(?:-(\d+))?$/;
+
+function highlightSourceLines(match) {
+    if (typeof match === "undefined") {
+        match = window.location.hash.match(lineNumbersRegex);
+    }
+    if (!match) {
+        return;
+    }
+    let from = parseInt(match[1], 10);
+    let to = from;
+    if (typeof match[2] !== "undefined") {
+        to = parseInt(match[2], 10);
+    }
+    if (to < from) {
+        const tmp = to;
+        to = from;
+        from = tmp;
+    }
+    let elem = document.getElementById(from);
+    if (!elem) {
+        return;
+    }
+    const x = document.getElementById(from);
+    if (x) {
+        x.scrollIntoView();
+    }
+    onEachLazy(document.getElementsByClassName("line-numbers"), e => {
+        onEachLazy(e.getElementsByTagName("span"), i_e => {
+            removeClass(i_e, "line-highlighted");
+        });
+    });
+    for (let i = from; i <= to; ++i) {
+        elem = document.getElementById(i);
+        if (!elem) {
+            break;
+        }
+        addClass(elem, "line-highlighted");
+    }
+}
+
+const handleSourceHighlight = (function() {
+    let prev_line_id = 0;
+
+    const set_fragment = name => {
+        const x = window.scrollX,
+            y = window.scrollY;
+        if (browserSupportsHistoryApi()) {
+            history.replaceState(null, null, "#" + name);
+            highlightSourceLines();
+        } else {
+            location.replace("#" + name);
+        }
+        // Prevent jumps when selecting one or many lines
+        window.scrollTo(x, y);
+    };
+
+    return ev => {
+        let cur_line_id = parseInt(ev.target.id, 10);
+        // It can happen when clicking not on a line number span.
+        if (isNaN(cur_line_id)) {
+            return;
+        }
+        ev.preventDefault();
+
+        if (ev.shiftKey && prev_line_id) {
+            // Swap selection if needed
+            if (prev_line_id > cur_line_id) {
+                const tmp = prev_line_id;
+                prev_line_id = cur_line_id;
+                cur_line_id = tmp;
+            }
+
+            set_fragment(prev_line_id + "-" + cur_line_id);
+        } else {
+            prev_line_id = cur_line_id;
+
+            set_fragment(cur_line_id);
+        }
+    };
+}());
+
+window.addEventListener("hashchange", () => {
+    const match = window.location.hash.match(lineNumbersRegex);
+    if (match) {
+        return highlightSourceLines(match);
+    }
+});
+
+onEachLazy(document.getElementsByClassName("line-numbers"), el => {
+    el.addEventListener("click", handleSourceHighlight);
+});
+
+highlightSourceLines();
+
+window.createSourceSidebar = createSourceSidebar;
+})();
diff --git a/src/librustdoc/html/static/js/storage.js b/src/librustdoc/html/static/js/storage.js
new file mode 100644
index 000000000..0c5389d45
--- /dev/null
+++ b/src/librustdoc/html/static/js/storage.js
@@ -0,0 +1,268 @@
+// storage.js is loaded in the `<head>` of all rustdoc pages and doesn't
+// use `async` or `defer`. That means it blocks further parsing and rendering
+// of the page: https://developer.mozilla.org/en-US/docs/Web/HTML/Element/script.
+// This makes it the correct place to act on settings that affect the display of
+// the page, so we don't see major layout changes during the load of the page.
+"use strict";
+
+const darkThemes = ["dark", "ayu"];
+window.currentTheme = document.getElementById("themeStyle");
+window.mainTheme = document.getElementById("mainThemeStyle");
+
+// WARNING: RUSTDOC_MOBILE_BREAKPOINT MEDIA QUERY
+// If you update this line, then you also need to update the two media queries with the same
+// warning in rustdoc.css
+window.RUSTDOC_MOBILE_BREAKPOINT = 701;
+
+const settingsDataset = (function() {
+    const settingsElement = document.getElementById("default-settings");
+    if (settingsElement === null) {
+        return null;
+    }
+    const dataset = settingsElement.dataset;
+    if (dataset === undefined) {
+        return null;
+    }
+    return dataset;
+})();
+
+function getSettingValue(settingName) {
+    const current = getCurrentValue(settingName);
+    if (current !== null) {
+        return current;
+    }
+    if (settingsDataset !== null) {
+        // See the comment for `default_settings.into_iter()` etc. in
+        // `Options::from_matches` in `librustdoc/config.rs`.
+        const def = settingsDataset[settingName.replace(/-/g,"_")];
+        if (def !== undefined) {
+            return def;
+        }
+    }
+    return null;
+}
+
+const localStoredTheme = getSettingValue("theme");
+
+const savedHref = [];
+
+// eslint-disable-next-line no-unused-vars
+function hasClass(elem, className) {
+    return elem && elem.classList && elem.classList.contains(className);
+}
+
+// eslint-disable-next-line no-unused-vars
+function addClass(elem, className) {
+    if (!elem || !elem.classList) {
+        return;
+    }
+    elem.classList.add(className);
+}
+
+// eslint-disable-next-line no-unused-vars
+function removeClass(elem, className) {
+    if (!elem || !elem.classList) {
+        return;
+    }
+    elem.classList.remove(className);
+}
+
+/**
+ * Run a callback for every element of an Array.
+ * @param {Array<?>}    arr        - The array to iterate over
+ * @param {function(?)} func       - The callback
+ * @param {boolean}     [reversed] - Whether to iterate in reverse
+ */
+function onEach(arr, func, reversed) {
+    if (arr && arr.length > 0 && func) {
+        if (reversed) {
+            const length = arr.length;
+            for (let i = length - 1; i >= 0; --i) {
+                if (func(arr[i])) {
+                    return true;
+                }
+            }
+        } else {
+            for (const elem of arr) {
+                if (func(elem)) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+
+/**
+ * Turn an HTMLCollection or a NodeList into an Array, then run a callback
+ * for every element. This is useful because iterating over an HTMLCollection
+ * or a "live" NodeList while modifying it can be very slow.
+ * https://developer.mozilla.org/en-US/docs/Web/API/HTMLCollection
+ * https://developer.mozilla.org/en-US/docs/Web/API/NodeList
+ * @param {NodeList<?>|HTMLCollection<?>} lazyArray  - An array to iterate over
+ * @param {function(?)}                   func       - The callback
+ * @param {boolean}                       [reversed] - Whether to iterate in reverse
+ */
+function onEachLazy(lazyArray, func, reversed) {
+    return onEach(
+        Array.prototype.slice.call(lazyArray),
+        func,
+        reversed);
+}
+
+function updateLocalStorage(name, value) {
+    try {
+        window.localStorage.setItem("rustdoc-" + name, value);
+    } catch (e) {
+        // localStorage is not accessible, do nothing
+    }
+}
+
+function getCurrentValue(name) {
+    try {
+        return window.localStorage.getItem("rustdoc-" + name);
+    } catch (e) {
+        return null;
+    }
+}
+
+function switchTheme(styleElem, mainStyleElem, newTheme, saveTheme) {
+    const newHref = mainStyleElem.href.replace(
+        /\/rustdoc([^/]*)\.css/, "/" + newTheme + "$1" + ".css");
+
+    // If this new value comes from a system setting or from the previously
+    // saved theme, no need to save it.
+    if (saveTheme) {
+        updateLocalStorage("theme", newTheme);
+    }
+
+    if (styleElem.href === newHref) {
+        return;
+    }
+
+    let found = false;
+    if (savedHref.length === 0) {
+        onEachLazy(document.getElementsByTagName("link"), el => {
+            savedHref.push(el.href);
+        });
+    }
+    onEach(savedHref, el => {
+        if (el === newHref) {
+            found = true;
+            return true;
+        }
+    });
+    if (found) {
+        styleElem.href = newHref;
+    }
+}
+
+// This function is called from "main.js".
+// eslint-disable-next-line no-unused-vars
+function useSystemTheme(value) {
+    if (value === undefined) {
+        value = true;
+    }
+
+    updateLocalStorage("use-system-theme", value);
+
+    // update the toggle if we're on the settings page
+    const toggle = document.getElementById("use-system-theme");
+    if (toggle && toggle instanceof HTMLInputElement) {
+        toggle.checked = value;
+    }
+}
+
+const updateSystemTheme = (function() {
+    if (!window.matchMedia) {
+        // fallback to the CSS computed value
+        return () => {
+            const cssTheme = getComputedStyle(document.documentElement)
+                .getPropertyValue("content");
+
+            switchTheme(
+                window.currentTheme,
+                window.mainTheme,
+                JSON.parse(cssTheme) || "light",
+                true
+            );
+        };
+    }
+
+    // only listen to (prefers-color-scheme: dark) because light is the default
+    const mql = window.matchMedia("(prefers-color-scheme: dark)");
+
+    function handlePreferenceChange(mql) {
+        const use = theme => {
+            switchTheme(window.currentTheme, window.mainTheme, theme, true);
+        };
+        // maybe the user has disabled the setting in the meantime!
+        if (getSettingValue("use-system-theme") !== "false") {
+            const lightTheme = getSettingValue("preferred-light-theme") || "light";
+            const darkTheme = getSettingValue("preferred-dark-theme") || "dark";
+
+            if (mql.matches) {
+                use(darkTheme);
+            } else {
+                // prefers a light theme, or has no preference
+                use(lightTheme);
+            }
+            // note: we save the theme so that it doesn't suddenly change when
+            // the user disables "use-system-theme" and reloads the page or
+            // navigates to another page
+        } else {
+            use(getSettingValue("theme"));
+        }
+    }
+
+    mql.addListener(handlePreferenceChange);
+
+    return () => {
+        handlePreferenceChange(mql);
+    };
+})();
+
+function switchToSavedTheme() {
+    switchTheme(
+        window.currentTheme,
+        window.mainTheme,
+        getSettingValue("theme") || "light",
+        false
+    );
+}
+
+if (getSettingValue("use-system-theme") !== "false" && window.matchMedia) {
+    // update the preferred dark theme if the user is already using a dark theme
+    // See https://github.com/rust-lang/rust/pull/77809#issuecomment-707875732
+    if (getSettingValue("use-system-theme") === null
+        && getSettingValue("preferred-dark-theme") === null
+        && darkThemes.indexOf(localStoredTheme) >= 0) {
+        updateLocalStorage("preferred-dark-theme", localStoredTheme);
+    }
+
+    // call the function to initialize the theme at least once!
+    updateSystemTheme();
+} else {
+    switchToSavedTheme();
+}
+
+if (getSettingValue("source-sidebar-show") === "true") {
+    // At this point in page load, `document.body` is not available yet.
+    // Set a class on the `<html>` element instead.
+    addClass(document.documentElement, "source-sidebar-expanded");
+}
+
+// If we navigate away (for example to a settings page), and then use the back or
+// forward button to get back to a page, the theme may have changed in the meantime.
+// But scripts may not be re-loaded in such a case due to the bfcache
+// (https://web.dev/bfcache/). The "pageshow" event triggers on such navigations.
+// Use that opportunity to update the theme.
+// We use a setTimeout with a 0 timeout here to put the change on the event queue.
+// For some reason, if we try to change the theme while the `pageshow` event is
+// running, it sometimes fails to take effect. The problem manifests on Chrome,
+// specifically when talking to a remote website with no caching.
+window.addEventListener("pageshow", ev => {
+    if (ev.persisted) {
+        setTimeout(switchToSavedTheme, 0);
+    }
+});
diff --git a/src/librustdoc/html/static/scrape-examples-help.md b/src/librustdoc/html/static/scrape-examples-help.md
new file mode 100644
index 000000000..035b2e18b
--- /dev/null
+++ b/src/librustdoc/html/static/scrape-examples-help.md
@@ -0,0 +1,34 @@
+Rustdoc will automatically scrape examples of documented items from the `examples/` directory of a project. These examples will be included within the generated documentation for that item. For example, if your library contains a public function:
+
+```rust
+// src/lib.rs
+pub fn a_func() {}
+```
+
+And you have an example calling this function:
+
+```rust
+// examples/ex.rs
+fn main() {
+  a_crate::a_func();
+}
+```
+
+Then this code snippet will be included in the documentation for `a_func`.
+
+## How to read scraped examples
+
+Scraped examples are shown as blocks of code from a given file. The relevant item will be highlighted. If the file is larger than a couple lines, only a small window will be shown which you can expand by clicking &varr; in the top-right. If a file contains multiple instances of an item, you can use the &pr; and &sc; buttons to toggle through each instance.
+
+If there is more than one file that contains examples, then you should click "More examples" to see these examples.
+
+
+## How Rustdoc scrapes examples
+
+When you run `cargo doc`, Rustdoc will analyze all the crates that match Cargo's `--examples` filter for instances of items that occur in the crates being documented. Then Rustdoc will include the source code of these instances in the generated documentation.
+
+Rustdoc has a few techniques to ensure this doesn't overwhelm documentation readers, and that it doesn't blow up the page size:
+
+1. For a given item, a maximum of 5 examples are included in the page. The remaining examples are just links to source code.
+2. Only one example is shown by default, and the remaining examples are hidden behind a toggle.
+3. For a given file that contains examples, only the item containing the examples will be included in the generated documentation.
diff --git a/src/librustdoc/html/static_files.rs b/src/librustdoc/html/static_files.rs
new file mode 100644
index 000000000..75f2b7e35
--- /dev/null
+++ b/src/librustdoc/html/static_files.rs
@@ -0,0 +1,168 @@
+//! Static files bundled with documentation output.
+//!
+//! All the static files are included here for centralized access in case anything other than the
+//! HTML rendering code (say, the theme checker) needs to access one of these files.
+//!
+//! Note about types: CSS and JavaScript files are included as `&'static str` to allow for the
+//! minifier to run on them. All other files are included as `&'static [u8]` so they can be
+//! directly written to a `Write` handle.
+
+/// The file contents of the main `rustdoc.css` file, responsible for the core layout of the page.
+pub(crate) static RUSTDOC_CSS: &str = include_str!("static/css/rustdoc.css");
+
+/// The file contents of `settings.css`, responsible for the items on the settings page.
+pub(crate) static SETTINGS_CSS: &str = include_str!("static/css/settings.css");
+
+/// The file contents of the `noscript.css` file, used in case JS isn't supported or is disabled.
+pub(crate) static NOSCRIPT_CSS: &str = include_str!("static/css/noscript.css");
+
+/// The file contents of `normalize.css`, included to even out standard elements between browser
+/// implementations.
+pub(crate) static NORMALIZE_CSS: &str = include_str!("static/css/normalize.css");
+
+/// The file contents of `main.js`, which contains the core JavaScript used on documentation pages,
+/// including search behavior and docblock folding, among others.
+pub(crate) static MAIN_JS: &str = include_str!("static/js/main.js");
+
+/// The file contents of `search.js`, which contains the search behavior.
+pub(crate) static SEARCH_JS: &str = include_str!("static/js/search.js");
+
+/// The file contents of `settings.js`, which contains the JavaScript used to handle the settings
+/// page.
+pub(crate) static SETTINGS_JS: &str = include_str!("static/js/settings.js");
+
+/// The file contents of `storage.js`, which contains functionality related to browser Local
+/// Storage, used to store documentation settings.
+pub(crate) static STORAGE_JS: &str = include_str!("static/js/storage.js");
+
+/// The file contents of `scraped-examples.js`, which contains functionality related to the
+/// --scrape-examples flag that inserts automatically-found examples of usages of items.
+pub(crate) static SCRAPE_EXAMPLES_JS: &str = include_str!("static/js/scrape-examples.js");
+
+pub(crate) static SCRAPE_EXAMPLES_HELP_MD: &str = include_str!("static/scrape-examples-help.md");
+
+/// The file contents of `wheel.svg`, the icon used for the settings button.
+pub(crate) static WHEEL_SVG: &[u8] = include_bytes!("static/images/wheel.svg");
+
+/// The file contents of `clipboard.svg`, the icon used for the "copy path" button.
+pub(crate) static CLIPBOARD_SVG: &[u8] = include_bytes!("static/images/clipboard.svg");
+
+/// The file contents of `down-arrow.svg`, the icon used for the crate choice combobox.
+pub(crate) static DOWN_ARROW_SVG: &[u8] = include_bytes!("static/images/down-arrow.svg");
+
+/// The file contents of `toggle-minus.svg`, the icon used for opened toggles.
+pub(crate) static TOGGLE_MINUS_PNG: &[u8] = include_bytes!("static/images/toggle-minus.svg");
+
+/// The file contents of `toggle-plus.svg`, the icon used for closed toggles.
+pub(crate) static TOGGLE_PLUS_PNG: &[u8] = include_bytes!("static/images/toggle-plus.svg");
+
+/// The contents of `COPYRIGHT.txt`, the license listing for files distributed with documentation
+/// output.
+pub(crate) static COPYRIGHT: &[u8] = include_bytes!("static/COPYRIGHT.txt");
+
+/// The contents of `LICENSE-APACHE.txt`, the text of the Apache License, version 2.0.
+pub(crate) static LICENSE_APACHE: &[u8] = include_bytes!("static/LICENSE-APACHE.txt");
+
+/// The contents of `LICENSE-MIT.txt`, the text of the MIT License.
+pub(crate) static LICENSE_MIT: &[u8] = include_bytes!("static/LICENSE-MIT.txt");
+
+/// The contents of `rust-logo.svg`, the default icon of the documentation.
+pub(crate) static RUST_LOGO_SVG: &[u8] = include_bytes!("static/images/rust-logo.svg");
+
+/// The default documentation favicons (SVG and PNG fallbacks)
+pub(crate) static RUST_FAVICON_SVG: &[u8] = include_bytes!("static/images/favicon.svg");
+pub(crate) static RUST_FAVICON_PNG_16: &[u8] = include_bytes!("static/images/favicon-16x16.png");
+pub(crate) static RUST_FAVICON_PNG_32: &[u8] = include_bytes!("static/images/favicon-32x32.png");
+
+/// The built-in themes given to every documentation site.
+pub(crate) mod themes {
+    /// The "light" theme, selected by default when no setting is available. Used as the basis for
+    /// the `--check-theme` functionality.
+    pub(crate) static LIGHT: &str = include_str!("static/css/themes/light.css");
+
+    /// The "dark" theme.
+    pub(crate) static DARK: &str = include_str!("static/css/themes/dark.css");
+
+    /// The "ayu" theme.
+    pub(crate) static AYU: &str = include_str!("static/css/themes/ayu.css");
+}
+
+/// Files related to the Fira Sans font.
+pub(crate) mod fira_sans {
+    /// The file `FiraSans-Regular.woff2`, the Regular variant of the Fira Sans font in woff2.
+    pub(crate) static REGULAR: &[u8] = include_bytes!("static/fonts/FiraSans-Regular.woff2");
+
+    /// The file `FiraSans-Medium.woff2`, the Medium variant of the Fira Sans font in woff2.
+    pub(crate) static MEDIUM: &[u8] = include_bytes!("static/fonts/FiraSans-Medium.woff2");
+
+    /// The file `FiraSans-LICENSE.txt`, the license text for the Fira Sans font.
+    pub(crate) static LICENSE: &[u8] = include_bytes!("static/fonts/FiraSans-LICENSE.txt");
+}
+
+/// Files related to the Source Serif 4 font.
+pub(crate) mod source_serif_4 {
+    /// The file `SourceSerif4-Regular.ttf.woff2`, the Regular variant of the Source Serif 4 font in
+    /// woff2.
+    pub(crate) static REGULAR: &[u8] =
+        include_bytes!("static/fonts/SourceSerif4-Regular.ttf.woff2");
+
+    /// The file `SourceSerif4-Bold.ttf.woff2`, the Bold variant of the Source Serif 4 font in
+    /// woff2.
+    pub(crate) static BOLD: &[u8] = include_bytes!("static/fonts/SourceSerif4-Bold.ttf.woff2");
+
+    /// The file `SourceSerif4-It.ttf.woff2`, the Italic variant of the Source Serif 4 font in
+    /// woff2.
+    pub(crate) static ITALIC: &[u8] = include_bytes!("static/fonts/SourceSerif4-It.ttf.woff2");
+
+    /// The file `SourceSerif4-LICENSE.txt`, the license text for the Source Serif 4 font.
+    pub(crate) static LICENSE: &[u8] = include_bytes!("static/fonts/SourceSerif4-LICENSE.md");
+}
+
+/// Files related to the Source Code Pro font.
+pub(crate) mod source_code_pro {
+    /// The file `SourceCodePro-Regular.ttf.woff2`, the Regular variant of the Source Code Pro font
+    /// in woff2.
+    pub(crate) static REGULAR: &[u8] =
+        include_bytes!("static/fonts/SourceCodePro-Regular.ttf.woff2");
+
+    /// The file `SourceCodePro-Semibold.ttf.woff2`, the Semibold variant of the Source Code Pro
+    /// font in woff2.
+    pub(crate) static SEMIBOLD: &[u8] =
+        include_bytes!("static/fonts/SourceCodePro-Semibold.ttf.woff2");
+
+    /// The file `SourceCodePro-It.ttf.woff2`, the Italic variant of the Source Code Pro font in
+    /// woff2.
+    pub(crate) static ITALIC: &[u8] = include_bytes!("static/fonts/SourceCodePro-It.ttf.woff2");
+
+    /// The file `SourceCodePro-LICENSE.txt`, the license text of the Source Code Pro font.
+    pub(crate) static LICENSE: &[u8] = include_bytes!("static/fonts/SourceCodePro-LICENSE.txt");
+}
+
+/// Files related to the Nanum Barun Gothic font.
+///
+/// These files are used to avoid some legacy CJK serif fonts in Windows.
+///
+/// Note that the Noto Sans KR font, which was used previously but was not very readable on Windows,
+/// has been replaced by the Nanum Barun Gothic font. This is due to Windows' implementation of font
+/// rendering that distorts OpenType fonts too much.
+///
+/// The font files were generated with these commands:
+///
+/// ```sh
+/// pyftsubset NanumBarunGothic.ttf \
+/// --unicodes=U+AC00-D7AF,U+1100-11FF,U+3130-318F,U+A960-A97F,U+D7B0-D7FF \
+/// --output-file=NanumBarunGothic.ttf.woff2 --flavor=woff2
+/// ```
+pub(crate) mod nanum_barun_gothic {
+    /// The file `NanumBarunGothic.ttf.woff2`, the Regular variant of the Nanum Barun Gothic font.
+    pub(crate) static REGULAR: &[u8] = include_bytes!("static/fonts/NanumBarunGothic.ttf.woff2");
+
+    /// The file `NanumBarunGothic-LICENSE.txt`, the license text of the Nanum Barun Gothic font.
+    pub(crate) static LICENSE: &[u8] = include_bytes!("static/fonts/NanumBarunGothic-LICENSE.txt");
+}
+
+/// Files related to the sidebar in rustdoc sources.
+pub(crate) mod sidebar {
+    /// File script to handle sidebar.
+    pub(crate) static SOURCE_SCRIPT: &str = include_str!("static/js/source-script.js");
+}
diff --git a/src/librustdoc/html/templates/STYLE.md b/src/librustdoc/html/templates/STYLE.md
new file mode 100644
index 000000000..fff65e3b5
--- /dev/null
+++ b/src/librustdoc/html/templates/STYLE.md
@@ -0,0 +1,37 @@
+# Style for Templates
+
+This directory has templates in the [Tera templating language](teradoc), which is very
+similar to [Jinja2](jinjadoc) and [Django](djangodoc) templates, and also to [Askama](askamadoc).
+
+[teradoc]: https://tera.netlify.app/docs/#templates
+[jinjadoc]: https://jinja.palletsprojects.com/en/3.0.x/templates/
+[djangodoc]: https://docs.djangoproject.com/en/3.2/topics/templates/
+[askamadoc]: https://docs.rs/askama/0.10.5/askama/
+
+We want our rendered output to have as little unnecessary whitespace as
+possible, so that pages load quickly. To achieve that we use Tera's
+[whitespace control] features. At the end of most lines, we put an empty comment
+tag with the whitespace control characters: `{#- -#}`. This causes all
+whitespace between the end of the line and the beginning of the next, including
+indentation, to be omitted on render. Sometimes we want to preserve a single
+space. In those cases we put the space at the end of the line, followed by
+`{# -#}`, which is a directive to remove following whitespace but not preceding.
+We also use the whitespace control characters in most instances of tags with
+control flow, for example `{%- if foo -%}`.
+
+[whitespace control]: https://tera.netlify.app/docs/#whitespace-control
+
+We want our templates to be readable, so we use indentation and newlines
+liberally. We indent by four spaces after opening an HTML tag _or_ a Tera
+tag. In most cases an HTML tag should be followed by a newline, but if the
+tag has simple contents and fits with its close tag on a single line, the
+contents don't necessarily need a new line.
+
+Tera templates support quite sophisticated control flow. To keep our templates
+simple and understandable, we use only a subset: `if` and `for`. In particular
+we avoid [assignments in the template logic](assignments) and [Tera
+macros](macros). This also may make things easier if we switch to a different
+Jinja-style template system, like Askama, in the future.
+
+[assignments]: https://tera.netlify.app/docs/#assignments
+[macros]: https://tera.netlify.app/docs/#macros
diff --git a/src/librustdoc/html/templates/page.html b/src/librustdoc/html/templates/page.html
new file mode 100644
index 000000000..8e25f6764
--- /dev/null
+++ b/src/librustdoc/html/templates/page.html
@@ -0,0 +1,148 @@
+<!DOCTYPE html> {#- -#}
+<html lang="en"> {#- -#}
+<head> {#- -#}
+    <meta charset="utf-8"> {#- -#}
+    <meta name="viewport" content="width=device-width, initial-scale=1.0"> {#- -#}
+    <meta name="generator" content="rustdoc"> {#- -#}
+    <meta name="description" content="{{page.description}}"> {#- -#}
+    <meta name="keywords" content="{{page.keywords}}"> {#- -#}
+    <title>{{page.title}}</title> {#- -#}
+    <link rel="preload" as="font" type="font/woff2" crossorigin href="{{static_root_path|safe}}SourceSerif4-Regular.ttf.woff2"> {#- -#}
+    <link rel="preload" as="font" type="font/woff2" crossorigin href="{{static_root_path|safe}}FiraSans-Regular.woff2"> {#- -#}
+    <link rel="preload" as="font" type="font/woff2" crossorigin href="{{static_root_path|safe}}FiraSans-Medium.woff2"> {#- -#}
+    <link rel="preload" as="font" type="font/woff2" crossorigin href="{{static_root_path|safe}}SourceCodePro-Regular.ttf.woff2"> {#- -#}
+    <link rel="preload" as="font" type="font/woff2" crossorigin href="{{static_root_path|safe}}SourceSerif4-Bold.ttf.woff2"> {#- -#}
+    <link rel="preload" as="font" type="font/woff2" crossorigin href="{{static_root_path|safe}}SourceCodePro-Semibold.ttf.woff2"> {#- -#}
+    <link rel="stylesheet" type="text/css" {# -#}
+          href="{{static_root_path|safe}}normalize{{page.resource_suffix}}.css"> {#- -#}
+    <link rel="stylesheet" type="text/css" {# -#}
+          href="{{static_root_path|safe}}rustdoc{{page.resource_suffix}}.css" {# -#}
+          id="mainThemeStyle"> {#- -#}
+    {%- for theme in themes -%}
+        <link rel="stylesheet" type="text/css" {# -#}
+            href="{{static_root_path|safe}}{{theme}}{{page.resource_suffix}}.css" {# -#}
+        {%- if theme == "light" -%}
+            id="themeStyle"
+        {%- else -%}
+            disabled
+        {%- endif -%}
+        >
+    {%- endfor -%}
+    <script id="default-settings" {# -#}
+      {% for (k, v) in layout.default_settings %}
+        data-{{k}}="{{v}}"
+      {%- endfor -%}
+    ></script> {#- -#}
+    <script src="{{static_root_path|safe}}storage{{page.resource_suffix}}.js"></script> {#- -#}
+    {%- if page.css_class.contains("crate") -%}
+    <script defer src="{{page.root_path|safe}}crates{{page.resource_suffix}}.js"></script> {#- -#}
+    {%- else if page.css_class == "source" -%}
+    <script defer src="{{static_root_path|safe}}source-script{{page.resource_suffix}}.js"></script> {#- -#}
+    <script defer src="{{page.root_path|safe}}source-files{{page.resource_suffix}}.js"></script> {#- -#}
+    {%- else if !page.css_class.contains("mod") -%}
+    <script defer src="sidebar-items{{page.resource_suffix}}.js"></script> {#- -#}
+    {%- endif -%}
+    <script defer src="{{static_root_path|safe}}main{{page.resource_suffix}}.js"></script> {#- -#}
+    {%- if layout.scrape_examples_extension -%}
+    <script defer src="{{page.root_path|safe}}scrape-examples{{page.resource_suffix}}.js"></script> {#- -#}
+    {%- endif -%}
+    <noscript> {#- -#}
+        <link rel="stylesheet" {# -#}
+           href="{{static_root_path|safe}}noscript{{page.resource_suffix}}.css"> {#- -#}
+    </noscript> {#- -#}
+    {%- if layout.css_file_extension.is_some() -%}
+        <link rel="stylesheet" type="text/css" {# -#}
+            href="{{static_root_path|safe}}theme{{page.resource_suffix}}.css"> {#- -#}
+    {%- endif -%}
+    {%- if !layout.favicon.is_empty() -%}
+        <link rel="icon" href="{{layout.favicon}}"> {#- -#}
+    {%- else -%}
+        <link rel="alternate icon" type="image/png" {# -#}
+            href="{{static_root_path|safe}}favicon-16x16{{page.resource_suffix}}.png"> {#- -#}
+        <link rel="alternate icon" type="image/png" {# -#}
+            href="{{static_root_path|safe}}favicon-32x32{{page.resource_suffix}}.png"> {#- -#}
+        <link rel="icon" type="image/svg+xml" {# -#}
+            href="{{static_root_path|safe}}favicon{{page.resource_suffix}}.svg"> {#- -#}
+    {%- endif -%}
+    {{- layout.external_html.in_header|safe -}}
+</head> {#- -#}
+<body class="rustdoc {{page.css_class}}"> {#- -#}
+    <!--[if lte IE 11]> {#- -#}
+    <div class="warning"> {#- -#}
+        This old browser is unsupported and will most likely display funky things. {#- -#}
+    </div> {#- -#}
+    <![endif]--> {#- -#}
+    {{- layout.external_html.before_content|safe -}}
+    <nav class="mobile-topbar"> {#- -#}
+        <button class="sidebar-menu-toggle">&#9776;</button> {#- -#}
+        <a class="sidebar-logo" href="{{page.root_path|safe}}{{krate_with_trailing_slash|safe}}index.html"> {#- -#}
+            <div class="logo-container"> {#- -#}
+            {%- if !layout.logo.is_empty() -%}
+                <img src="{{layout.logo}}" alt="logo"> {#- -#}
+            {%- else -%}
+                <img class="rust-logo" src="{{static_root_path|safe}}rust-logo{{page.resource_suffix}}.svg" alt="logo"> {#- -#}
+            {%- endif -%}
+            </div> {#- -#}
+        </a> {#- -#}
+        <h2 class="location"></h2> {#- -#}
+    </nav> {#- -#}
+    <nav class="sidebar"> {#- -#}
+        <a class="sidebar-logo" href="{{page.root_path|safe}}{{krate_with_trailing_slash|safe}}index.html"> {#- -#}
+            <div class="logo-container"> {#- -#}
+                {%- if !layout.logo.is_empty()  %}
+                    <img src="{{layout.logo}}" alt="logo"> {#- -#}
+                {%- else -%}
+                    <img class="rust-logo" src="{{static_root_path|safe}}rust-logo{{page.resource_suffix}}.svg" alt="logo"> {#- -#}
+                {%- endif -%}
+            </div> {#- -#}
+        </a> {#- -#}
+        {{- sidebar|safe -}}
+    </nav> {#- -#}
+    <main> {#- -#}
+        <div class="width-limiter"> {#- -#}
+            <div class="sub-container"> {#- -#}
+                <a class="sub-logo-container" href="{{page.root_path|safe}}{{krate_with_trailing_slash|safe}}index.html"> {#- -#}
+                    {%- if !layout.logo.is_empty()  %}
+                        <img src="{{layout.logo}}" alt="logo"> {#- -#}
+                    {%- else -%}
+                        <img class="rust-logo" src="{{static_root_path|safe}}rust-logo{{page.resource_suffix}}.svg" alt="logo"> {#- -#}
+                    {%- endif -%}
+                </a> {#- -#}
+                <nav class="sub"> {#- -#}
+                    <form class="search-form"> {#- -#}
+                        <div class="search-container"> {#- -#}
+                            <span></span> {#- This empty span is a hacky fix for Safari - See #93184 -#}
+                            <input {# -#}
+                                class="search-input" {# -#}
+                                name="search" {# -#}
+                                autocomplete="off" {# -#}
+                                spellcheck="false" {# -#}
+                                placeholder="Click or press ‘S’ to search, ‘?’ for more options…" {# -#}
+                                type="search"> {#- -#}
+                            <div id="help-button" title="help" tabindex="-1"> {#- -#}
+                                <button type="button">?</button> {#- -#}
+                            </div> {#- -#}
+                            <div id="settings-menu" tabindex="-1"> {#- -#}
+                                <a href="{{page.root_path|safe}}settings.html" title="settings"> {#- -#}
+                                    <img width="22" height="22" alt="Change settings" {# -#}
+                                     src="{{static_root_path|safe}}wheel{{page.resource_suffix}}.svg"> {#- -#}
+                                </a> {#- -#}
+                            </div> {#- -#}
+                        </div> {#- -#}
+                    </form> {#- -#}
+                </nav> {#- -#}
+            </div> {#- -#}
+            <section id="main-content" class="content">{{- content|safe -}}</section> {#- -#}
+        </div> {#- -#}
+    </main> {#- -#}
+    {{- layout.external_html.after_content|safe -}}
+    <div id="rustdoc-vars" {# -#}
+         data-root-path="{{page.root_path|safe}}" {# -#}
+         data-current-crate="{{layout.krate}}" {# -#}
+         data-themes="{{themes|join(",") }}" {# -#}
+         data-resource-suffix="{{page.resource_suffix}}" {# -#}
+         data-rustdoc-version="{{rustdoc_version}}" {# -#}
+    > {#- -#}
+    </div> {#- -#}
+</body> {#- -#}
+</html> {#- -#}
diff --git a/src/librustdoc/html/templates/print_item.html b/src/librustdoc/html/templates/print_item.html
new file mode 100644
index 000000000..c755157d2
--- /dev/null
+++ b/src/librustdoc/html/templates/print_item.html
@@ -0,0 +1,30 @@
+<div class="main-heading"> {#- -#}
+    <h1 class="fqn"> {#- -#}
+        <span class="in-band"> {#- -#}
+            {{-typ-}}
+            {#- The breadcrumbs of the item path, like std::string -#}
+            {%- for component in path_components -%}
+            <a href="{{component.path|safe}}index.html">{{component.name}}</a>::<wbr>
+            {%- endfor -%}
+            <a class="{{item_type}}" href="#">{{name}}</a> {#- -#}
+            <button id="copy-path" onclick="copy_path(this)" title="Copy item path to clipboard"> {#- -#}
+                <img src="{{static_root_path|safe}}clipboard{{page.resource_suffix}}.svg" {# -#}
+                    width="19" height="18" {# -#}
+                    alt="Copy item path"> {#- -#}
+            </button> {#- -#}
+        </span> {#- -#}
+    </h1> {#- -#}
+    <span class="out-of-band"> {#- -#}
+        {% if !stability_since_raw.is_empty() %}
+        {{- stability_since_raw|safe }} · {# -#}
+        {% endif %}
+        {%- match src_href -%}
+            {%- when Some with (href) -%}
+                <a class="srclink" href="{{href|safe}}">source</a> · {# -#}
+            {%- else -%}
+        {%- endmatch -%}
+        <a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs"> {#- -#}
+            [<span class="inner">&#x2212;</span>] {#- -#}
+        </a> {#- -#}
+    </span> {#- -#}
+</div> {#- -#}
diff --git a/src/librustdoc/html/tests.rs b/src/librustdoc/html/tests.rs
new file mode 100644
index 000000000..437d3995e
--- /dev/null
+++ b/src/librustdoc/html/tests.rs
@@ -0,0 +1,50 @@
+use crate::html::format::href_relative_parts;
+use rustc_span::{sym, Symbol};
+
+fn assert_relative_path(expected: &[Symbol], relative_to_fqp: &[Symbol], fqp: &[Symbol]) {
+    // No `create_default_session_globals_then` call is needed here because all
+    // the symbols used are static, and no `Symbol::intern` calls occur.
+    assert_eq!(expected, href_relative_parts(&fqp, &relative_to_fqp).collect::<Vec<_>>());
+}
+
+#[test]
+fn href_relative_parts_basic() {
+    let relative_to_fqp = &[sym::std, sym::vec];
+    let fqp = &[sym::std, sym::iter];
+    assert_relative_path(&[sym::dotdot, sym::iter], relative_to_fqp, fqp);
+}
+
+#[test]
+fn href_relative_parts_parent_module() {
+    let relative_to_fqp = &[sym::std, sym::vec];
+    let fqp = &[sym::std];
+    assert_relative_path(&[sym::dotdot], relative_to_fqp, fqp);
+}
+
+#[test]
+fn href_relative_parts_different_crate() {
+    let relative_to_fqp = &[sym::std, sym::vec];
+    let fqp = &[sym::core, sym::iter];
+    assert_relative_path(&[sym::dotdot, sym::dotdot, sym::core, sym::iter], relative_to_fqp, fqp);
+}
+
+#[test]
+fn href_relative_parts_same_module() {
+    let relative_to_fqp = &[sym::std, sym::vec];
+    let fqp = &[sym::std, sym::vec];
+    assert_relative_path(&[], relative_to_fqp, fqp);
+}
+
+#[test]
+fn href_relative_parts_child_module() {
+    let relative_to_fqp = &[sym::std];
+    let fqp = &[sym::std, sym::vec];
+    assert_relative_path(&[sym::vec], relative_to_fqp, fqp);
+}
+
+#[test]
+fn href_relative_parts_root() {
+    let relative_to_fqp = &[];
+    let fqp = &[sym::std];
+    assert_relative_path(&[sym::std], relative_to_fqp, fqp);
+}
diff --git a/src/librustdoc/html/toc.rs b/src/librustdoc/html/toc.rs
new file mode 100644
index 000000000..a12c2a6a1
--- /dev/null
+++ b/src/librustdoc/html/toc.rs
@@ -0,0 +1,191 @@
+//! Table-of-contents creation.
+
+/// A (recursive) table of contents
+#[derive(Debug, PartialEq)]
+pub(crate) struct Toc {
+    /// The levels are strictly decreasing, i.e.
+    ///
+    /// `entries[0].level >= entries[1].level >= ...`
+    ///
+    /// Normally they are equal, but can differ in cases like A and B,
+    /// both of which end up in the same `Toc` as they have the same
+    /// parent (Main).
+    ///
+    /// ```text
+    /// # Main
+    /// ### A
+    /// ## B
+    /// ```
+    entries: Vec<TocEntry>,
+}
+
+impl Toc {
+    fn count_entries_with_level(&self, level: u32) -> usize {
+        self.entries.iter().filter(|e| e.level == level).count()
+    }
+}
+
+#[derive(Debug, PartialEq)]
+pub(crate) struct TocEntry {
+    level: u32,
+    sec_number: String,
+    name: String,
+    id: String,
+    children: Toc,
+}
+
+/// Progressive construction of a table of contents.
+#[derive(PartialEq)]
+pub(crate) struct TocBuilder {
+    top_level: Toc,
+    /// The current hierarchy of parent headings, the levels are
+    /// strictly increasing (i.e., `chain[0].level < chain[1].level <
+    /// ...`) with each entry being the most recent occurrence of a
+    /// heading with that level (it doesn't include the most recent
+    /// occurrences of every level, just, if it *is* in `chain` then
+    /// it is the most recent one).
+    ///
+    /// We also have `chain[0].level <= top_level.entries[last]`.
+    chain: Vec<TocEntry>,
+}
+
+impl TocBuilder {
+    pub(crate) fn new() -> TocBuilder {
+        TocBuilder { top_level: Toc { entries: Vec::new() }, chain: Vec::new() }
+    }
+
+    /// Converts into a true `Toc` struct.
+    pub(crate) fn into_toc(mut self) -> Toc {
+        // we know all levels are >= 1.
+        self.fold_until(0);
+        self.top_level
+    }
+
+    /// Collapse the chain until the first heading more important than
+    /// `level` (i.e., lower level)
+    ///
+    /// Example:
+    ///
+    /// ```text
+    /// ## A
+    /// # B
+    /// # C
+    /// ## D
+    /// ## E
+    /// ### F
+    /// #### G
+    /// ### H
+    /// ```
+    ///
+    /// If we are considering H (i.e., level 3), then A and B are in
+    /// self.top_level, D is in C.children, and C, E, F, G are in
+    /// self.chain.
+    ///
+    /// When we attempt to push H, we realize that first G is not the
+    /// parent (level is too high) so it is popped from chain and put
+    /// into F.children, then F isn't the parent (level is equal, aka
+    /// sibling), so it's also popped and put into E.children.
+    ///
+    /// This leaves us looking at E, which does have a smaller level,
+    /// and, by construction, it's the most recent thing with smaller
+    /// level, i.e., it's the immediate parent of H.
+    fn fold_until(&mut self, level: u32) {
+        let mut this = None;
+        loop {
+            match self.chain.pop() {
+                Some(mut next) => {
+                    next.children.entries.extend(this);
+                    if next.level < level {
+                        // this is the parent we want, so return it to
+                        // its rightful place.
+                        self.chain.push(next);
+                        return;
+                    } else {
+                        this = Some(next);
+                    }
+                }
+                None => {
+                    self.top_level.entries.extend(this);
+                    return;
+                }
+            }
+        }
+    }
+
+    /// Push a level `level` heading into the appropriate place in the
+    /// hierarchy, returning a string containing the section number in
+    /// `<num>.<num>.<num>` format.
+    pub(crate) fn push(&mut self, level: u32, name: String, id: String) -> &str {
+        assert!(level >= 1);
+
+        // collapse all previous sections into their parents until we
+        // get to relevant heading (i.e., the first one with a smaller
+        // level than us)
+        self.fold_until(level);
+
+        let mut sec_number;
+        {
+            let (toc_level, toc) = match self.chain.last() {
+                None => {
+                    sec_number = String::new();
+                    (0, &self.top_level)
+                }
+                Some(entry) => {
+                    sec_number = entry.sec_number.clone();
+                    sec_number.push('.');
+                    (entry.level, &entry.children)
+                }
+            };
+            // fill in any missing zeros, e.g., for
+            // # Foo (1)
+            // ### Bar (1.0.1)
+            for _ in toc_level..level - 1 {
+                sec_number.push_str("0.");
+            }
+            let number = toc.count_entries_with_level(level);
+            sec_number.push_str(&(number + 1).to_string())
+        }
+
+        self.chain.push(TocEntry {
+            level,
+            name,
+            sec_number,
+            id,
+            children: Toc { entries: Vec::new() },
+        });
+
+        // get the thing we just pushed, so we can borrow the string
+        // out of it with the right lifetime
+        let just_inserted = self.chain.last_mut().unwrap();
+        &just_inserted.sec_number
+    }
+}
+
+impl Toc {
+    fn print_inner(&self, v: &mut String) {
+        use std::fmt::Write as _;
+
+        v.push_str("<ul>");
+        for entry in &self.entries {
+            // recursively format this table of contents
+            let _ = write!(
+                v,
+                "\n<li><a href=\"#{id}\">{num} {name}</a>",
+                id = entry.id,
+                num = entry.sec_number,
+                name = entry.name
+            );
+            entry.children.print_inner(&mut *v);
+            v.push_str("</li>");
+        }
+        v.push_str("</ul>");
+    }
+    pub(crate) fn print(&self) -> String {
+        let mut v = String::new();
+        self.print_inner(&mut v);
+        v
+    }
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/src/librustdoc/html/toc/tests.rs b/src/librustdoc/html/toc/tests.rs
new file mode 100644
index 000000000..014f34686
--- /dev/null
+++ b/src/librustdoc/html/toc/tests.rs
@@ -0,0 +1,79 @@
+use super::{Toc, TocBuilder, TocEntry};
+
+#[test]
+fn builder_smoke() {
+    let mut builder = TocBuilder::new();
+
+    // this is purposely not using a fancy macro like below so
+    // that we're sure that this is doing the correct thing, and
+    // there's been no macro mistake.
+    macro_rules! push {
+        ($level: expr, $name: expr) => {
+            assert_eq!(builder.push($level, $name.to_string(), "".to_string()), $name);
+        };
+    }
+    push!(2, "0.1");
+    push!(1, "1");
+    {
+        push!(2, "1.1");
+        {
+            push!(3, "1.1.1");
+            push!(3, "1.1.2");
+        }
+        push!(2, "1.2");
+        {
+            push!(3, "1.2.1");
+            push!(3, "1.2.2");
+        }
+    }
+    push!(1, "2");
+    push!(1, "3");
+    {
+        push!(4, "3.0.0.1");
+        {
+            push!(6, "3.0.0.1.0.1");
+        }
+        push!(4, "3.0.0.2");
+        push!(2, "3.1");
+        {
+            push!(4, "3.1.0.1");
+        }
+    }
+
+    macro_rules! toc {
+        ($(($level: expr, $name: expr, $(($sub: tt))* )),*) => {
+            Toc {
+                entries: vec![
+                    $(
+                        TocEntry {
+                            level: $level,
+                            name: $name.to_string(),
+                            sec_number: $name.to_string(),
+                            id: "".to_string(),
+                            children: toc!($($sub),*)
+                        }
+                        ),*
+                    ]
+            }
+        }
+    }
+    let expected = toc!(
+        (2, "0.1",),
+        (
+            1,
+            "1",
+            ((2, "1.1", ((3, "1.1.1",))((3, "1.1.2",))))((
+                2,
+                "1.2",
+                ((3, "1.2.1",))((3, "1.2.2",))
+            ))
+        ),
+        (1, "2",),
+        (
+            1,
+            "3",
+            ((4, "3.0.0.1", ((6, "3.0.0.1.0.1",))))((4, "3.0.0.2",))((2, "3.1", ((4, "3.1.0.1",))))
+        )
+    );
+    assert_eq!(expected, builder.into_toc());
+}
diff --git a/src/librustdoc/html/url_parts_builder.rs b/src/librustdoc/html/url_parts_builder.rs
new file mode 100644
index 000000000..1e6af6af6
--- /dev/null
+++ b/src/librustdoc/html/url_parts_builder.rs
@@ -0,0 +1,180 @@
+use std::fmt::{self, Write};
+
+use rustc_span::Symbol;
+
+/// A builder that allows efficiently and easily constructing the part of a URL
+/// after the domain: `nightly/core/str/struct.Bytes.html`.
+///
+/// This type is a wrapper around the final `String` buffer,
+/// but its API is like that of a `Vec` of URL components.
+#[derive(Debug)]
+pub(crate) struct UrlPartsBuilder {
+    buf: String,
+}
+
+impl UrlPartsBuilder {
+    /// Create an empty buffer.
+    #[allow(dead_code)]
+    pub(crate) fn new() -> Self {
+        Self { buf: String::new() }
+    }
+
+    /// Create an empty buffer with capacity for the specified number of bytes.
+    fn with_capacity_bytes(count: usize) -> Self {
+        Self { buf: String::with_capacity(count) }
+    }
+
+    /// Create a buffer with one URL component.
+    ///
+    /// # Examples
+    ///
+    /// Basic usage:
+    ///
+    /// ```ignore (private-type)
+    /// let builder = UrlPartsBuilder::singleton("core");
+    /// assert_eq!(builder.finish(), "core");
+    /// ```
+    ///
+    /// Adding more components afterward.
+    ///
+    /// ```ignore (private-type)
+    /// let mut builder = UrlPartsBuilder::singleton("core");
+    /// builder.push("str");
+    /// builder.push_front("nightly");
+    /// assert_eq!(builder.finish(), "nightly/core/str");
+    /// ```
+    pub(crate) fn singleton(part: &str) -> Self {
+        Self { buf: part.to_owned() }
+    }
+
+    /// Push a component onto the buffer.
+    ///
+    /// # Examples
+    ///
+    /// Basic usage:
+    ///
+    /// ```ignore (private-type)
+    /// let mut builder = UrlPartsBuilder::new();
+    /// builder.push("core");
+    /// builder.push("str");
+    /// builder.push("struct.Bytes.html");
+    /// assert_eq!(builder.finish(), "core/str/struct.Bytes.html");
+    /// ```
+    pub(crate) fn push(&mut self, part: &str) {
+        if !self.buf.is_empty() {
+            self.buf.push('/');
+        }
+        self.buf.push_str(part);
+    }
+
+    /// Push a component onto the buffer, using [`format!`]'s formatting syntax.
+    ///
+    /// # Examples
+    ///
+    /// Basic usage (equivalent to the example for [`UrlPartsBuilder::push`]):
+    ///
+    /// ```ignore (private-type)
+    /// let mut builder = UrlPartsBuilder::new();
+    /// builder.push("core");
+    /// builder.push("str");
+    /// builder.push_fmt(format_args!("{}.{}.html", "struct", "Bytes"));
+    /// assert_eq!(builder.finish(), "core/str/struct.Bytes.html");
+    /// ```
+    pub(crate) fn push_fmt(&mut self, args: fmt::Arguments<'_>) {
+        if !self.buf.is_empty() {
+            self.buf.push('/');
+        }
+        self.buf.write_fmt(args).unwrap()
+    }
+
+    /// Push a component onto the front of the buffer.
+    ///
+    /// # Examples
+    ///
+    /// Basic usage:
+    ///
+    /// ```ignore (private-type)
+    /// let mut builder = UrlPartsBuilder::new();
+    /// builder.push("core");
+    /// builder.push("str");
+    /// builder.push_front("nightly");
+    /// builder.push("struct.Bytes.html");
+    /// assert_eq!(builder.finish(), "nightly/core/str/struct.Bytes.html");
+    /// ```
+    pub(crate) fn push_front(&mut self, part: &str) {
+        let is_empty = self.buf.is_empty();
+        self.buf.reserve(part.len() + if !is_empty { 1 } else { 0 });
+        self.buf.insert_str(0, part);
+        if !is_empty {
+            self.buf.insert(part.len(), '/');
+        }
+    }
+
+    /// Get the final `String` buffer.
+    pub(crate) fn finish(self) -> String {
+        self.buf
+    }
+}
+
+/// This is just a guess at the average length of a URL part,
+/// used for [`String::with_capacity`] calls in the [`FromIterator`]
+/// and [`Extend`] impls, and for [estimating item path lengths].
+///
+/// The value `8` was chosen for two main reasons:
+///
+/// * It seems like a good guess for the average part length.
+/// * jemalloc's size classes are all multiples of eight,
+///   which means that the amount of memory it allocates will often match
+///   the amount requested, avoiding wasted bytes.
+///
+/// [estimating item path lengths]: estimate_item_path_byte_length
+const AVG_PART_LENGTH: usize = 8;
+
+/// Estimate the number of bytes in an item's path, based on how many segments it has.
+///
+/// **Note:** This is only to be used with, e.g., [`String::with_capacity()`];
+/// the return value is just a rough estimate.
+pub(crate) const fn estimate_item_path_byte_length(segment_count: usize) -> usize {
+    AVG_PART_LENGTH * segment_count
+}
+
+impl<'a> FromIterator<&'a str> for UrlPartsBuilder {
+    fn from_iter<T: IntoIterator<Item = &'a str>>(iter: T) -> Self {
+        let iter = iter.into_iter();
+        let mut builder = Self::with_capacity_bytes(AVG_PART_LENGTH * iter.size_hint().0);
+        iter.for_each(|part| builder.push(part));
+        builder
+    }
+}
+
+impl<'a> Extend<&'a str> for UrlPartsBuilder {
+    fn extend<T: IntoIterator<Item = &'a str>>(&mut self, iter: T) {
+        let iter = iter.into_iter();
+        self.buf.reserve(AVG_PART_LENGTH * iter.size_hint().0);
+        iter.for_each(|part| self.push(part));
+    }
+}
+
+impl FromIterator<Symbol> for UrlPartsBuilder {
+    fn from_iter<T: IntoIterator<Item = Symbol>>(iter: T) -> Self {
+        // This code has to be duplicated from the `&str` impl because of
+        // `Symbol::as_str`'s lifetimes.
+        let iter = iter.into_iter();
+        let mut builder = Self::with_capacity_bytes(AVG_PART_LENGTH * iter.size_hint().0);
+        iter.for_each(|part| builder.push(part.as_str()));
+        builder
+    }
+}
+
+impl Extend<Symbol> for UrlPartsBuilder {
+    fn extend<T: IntoIterator<Item = Symbol>>(&mut self, iter: T) {
+        // This code has to be duplicated from the `&str` impl because of
+        // `Symbol::as_str`'s lifetimes.
+        let iter = iter.into_iter();
+        self.buf.reserve(AVG_PART_LENGTH * iter.size_hint().0);
+        iter.for_each(|part| self.push(part.as_str()));
+    }
+}
+
+#[cfg(test)]
+mod tests;
diff --git a/src/librustdoc/html/url_parts_builder/tests.rs b/src/librustdoc/html/url_parts_builder/tests.rs
new file mode 100644
index 000000000..636e1ab55
--- /dev/null
+++ b/src/librustdoc/html/url_parts_builder/tests.rs
@@ -0,0 +1,64 @@
+use super::*;
+
+fn t(builder: UrlPartsBuilder, expect: &str) {
+    assert_eq!(builder.finish(), expect);
+}
+
+#[test]
+fn empty() {
+    t(UrlPartsBuilder::new(), "");
+}
+
+#[test]
+fn singleton() {
+    t(UrlPartsBuilder::singleton("index.html"), "index.html");
+}
+
+#[test]
+fn push_several() {
+    let mut builder = UrlPartsBuilder::new();
+    builder.push("core");
+    builder.push("str");
+    builder.push("struct.Bytes.html");
+    t(builder, "core/str/struct.Bytes.html");
+}
+
+#[test]
+fn push_front_empty() {
+    let mut builder = UrlPartsBuilder::new();
+    builder.push_front("page.html");
+    t(builder, "page.html");
+}
+
+#[test]
+fn push_front_non_empty() {
+    let mut builder = UrlPartsBuilder::new();
+    builder.push("core");
+    builder.push("str");
+    builder.push("struct.Bytes.html");
+    builder.push_front("nightly");
+    t(builder, "nightly/core/str/struct.Bytes.html");
+}
+
+#[test]
+fn push_fmt() {
+    let mut builder = UrlPartsBuilder::new();
+    builder.push_fmt(format_args!("{}", "core"));
+    builder.push("str");
+    builder.push_front("nightly");
+    builder.push_fmt(format_args!("{}.{}.html", "struct", "Bytes"));
+    t(builder, "nightly/core/str/struct.Bytes.html");
+}
+
+#[test]
+fn collect() {
+    t(["core", "str"].into_iter().collect(), "core/str");
+    t(["core", "str", "struct.Bytes.html"].into_iter().collect(), "core/str/struct.Bytes.html");
+}
+
+#[test]
+fn extend() {
+    let mut builder = UrlPartsBuilder::singleton("core");
+    builder.extend(["str", "struct.Bytes.html"]);
+    t(builder, "core/str/struct.Bytes.html");
+}