diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index a116ed686d90e..03454bb8b7ff0 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -2329,14 +2329,14 @@ impl Clean for (&hir::MacroDef<'_>, Option) { if matchers.len() <= 1 { format!( "{}macro {}{} {{\n ...\n}}", - vis.print_with_space(cx.tcx, def_id), + vis.print_with_space(cx.tcx, def_id, &cx.cache), name, matchers.iter().map(|span| span.to_src(cx)).collect::(), ) } else { format!( "{}macro {} {{\n{}}}", - vis.print_with_space(cx.tcx, def_id), + vis.print_with_space(cx.tcx, def_id, &cx.cache), name, matchers .iter() diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs index c767b9dd85bf9..86bce8b8707a0 100644 --- a/src/librustdoc/clean/types.rs +++ b/src/librustdoc/clean/types.rs @@ -37,7 +37,7 @@ use crate::clean::inline; use crate::clean::types::Type::{QPath, ResolvedPath}; use crate::clean::Clean; use crate::core::DocContext; -use crate::formats::cache::cache; +use crate::formats::cache::Cache; use crate::formats::item_type::ItemType; use crate::html::render::cache::ExternalLocation; @@ -169,8 +169,8 @@ impl Item { self.attrs.collapsed_doc_value() } - crate fn links(&self) -> Vec { - self.attrs.links(&self.def_id.krate) + crate fn links(&self, cache: &Cache) -> Vec { + self.attrs.links(&self.def_id.krate, cache) } crate fn is_crate(&self) -> bool { @@ -826,7 +826,7 @@ impl Attributes { /// Gets links as a vector /// /// Cache must be populated before call - crate fn links(&self, krate: &CrateNum) -> Vec { + crate fn links(&self, krate: &CrateNum, cache: &Cache) -> Vec { use crate::html::format::href; use crate::html::render::CURRENT_DEPTH; @@ -835,7 +835,7 @@ impl Attributes { .filter_map(|ItemLink { link: s, link_text, did, fragment }| { match *did { Some(did) => { - if let Some((mut href, ..)) = href(did) { + if let Some((mut href, ..)) = href(did, cache) { if let Some(ref fragment) = *fragment { href.push('#'); href.push_str(fragment); @@ -851,7 +851,6 @@ impl Attributes { } None => { if let Some(ref fragment) = *fragment { - let cache = cache(); let url = match cache.extern_locations.get(krate) { Some(&(_, _, ExternalLocation::Local)) => { let depth = CURRENT_DEPTH.with(|l| l.get()); @@ -1177,6 +1176,13 @@ impl GetDefId for FnRetTy { DefaultReturn => None, } } + + fn def_id_full(&self, cache: &Cache) -> Option { + match *self { + Return(ref ty) => ty.def_id_full(cache), + DefaultReturn => None, + } + } } #[derive(Clone, Debug)] @@ -1299,13 +1305,31 @@ crate enum TypeKind { } crate trait GetDefId { + /// Use this method to get the [`DefId`] of a [`clean`] AST node. + /// This will return [`None`] when called on a primitive [`clean::Type`]. + /// Use [`Self::def_id_full`] if you want to include primitives. + /// + /// [`clean`]: crate::clean + /// [`clean::Type`]: crate::clean::Type + // FIXME: get rid of this function and always use `def_id_full` fn def_id(&self) -> Option; + + /// Use this method to get the [DefId] of a [clean] AST node, including [PrimitiveType]s. + /// + /// See [`Self::def_id`] for more. + /// + /// [clean]: crate::clean + fn def_id_full(&self, cache: &Cache) -> Option; } impl GetDefId for Option { fn def_id(&self) -> Option { self.as_ref().and_then(|d| d.def_id()) } + + fn def_id_full(&self, cache: &Cache) -> Option { + self.as_ref().and_then(|d| d.def_id_full(cache)) + } } impl Type { @@ -1393,30 +1417,40 @@ impl Type { } } -impl GetDefId for Type { - fn def_id(&self) -> Option { - match *self { - ResolvedPath { did, .. } => Some(did), - Primitive(p) => cache().primitive_locations.get(&p).cloned(), - BorrowedRef { type_: box Generic(..), .. } => { - Primitive(PrimitiveType::Reference).def_id() - } - BorrowedRef { ref type_, .. } => type_.def_id(), +impl Type { + fn inner_def_id(&self, cache: Option<&Cache>) -> Option { + let t: PrimitiveType = match *self { + ResolvedPath { did, .. } => return Some(did), + Primitive(p) => return cache.and_then(|c| c.primitive_locations.get(&p).cloned()), + BorrowedRef { type_: box Generic(..), .. } => PrimitiveType::Reference, + BorrowedRef { ref type_, .. } => return type_.inner_def_id(cache), Tuple(ref tys) => { if tys.is_empty() { - Primitive(PrimitiveType::Unit).def_id() + PrimitiveType::Unit } else { - Primitive(PrimitiveType::Tuple).def_id() + PrimitiveType::Tuple } } - BareFunction(..) => Primitive(PrimitiveType::Fn).def_id(), - Never => Primitive(PrimitiveType::Never).def_id(), - Slice(..) => Primitive(PrimitiveType::Slice).def_id(), - Array(..) => Primitive(PrimitiveType::Array).def_id(), - RawPointer(..) => Primitive(PrimitiveType::RawPointer).def_id(), - QPath { ref self_type, .. } => self_type.def_id(), - _ => None, - } + BareFunction(..) => PrimitiveType::Fn, + Never => PrimitiveType::Never, + Slice(..) => PrimitiveType::Slice, + Array(..) => PrimitiveType::Array, + RawPointer(..) => PrimitiveType::RawPointer, + QPath { ref self_type, .. } => return self_type.inner_def_id(cache), + // FIXME: remove this wildcard + _ => return None, + }; + cache.and_then(|c| Primitive(t).def_id_full(c)) + } +} + +impl GetDefId for Type { + fn def_id(&self) -> Option { + self.inner_def_id(None) + } + + fn def_id_full(&self, cache: &Cache) -> Option { + self.inner_def_id(Some(cache)) } } @@ -1817,6 +1851,10 @@ impl GetDefId for Typedef { fn def_id(&self) -> Option { self.type_.def_id() } + + fn def_id_full(&self, cache: &Cache) -> Option { + self.type_.def_id_full(cache) + } } #[derive(Clone, Debug)] diff --git a/src/librustdoc/clean/utils.rs b/src/librustdoc/clean/utils.rs index 0f5495c831058..869d48fc25e07 100644 --- a/src/librustdoc/clean/utils.rs +++ b/src/librustdoc/clean/utils.rs @@ -177,7 +177,7 @@ crate fn get_real_types( return res; } if arg.is_full_generic() { - let arg_s = Symbol::intern(&arg.print().to_string()); + let arg_s = Symbol::intern(&arg.print(&cx.cache).to_string()); if let Some(where_pred) = generics.where_predicates.iter().find(|g| match g { WherePredicate::BoundPredicate { ty, .. } => ty.def_id() == arg.def_id(), _ => false, @@ -473,7 +473,7 @@ crate fn resolve_type(cx: &DocContext<'_>, path: Path, id: hir::HirId) -> Type { return Generic(kw::SelfUpper); } Res::Def(DefKind::TyParam, _) if path.segments.len() == 1 => { - return Generic(Symbol::intern(&format!("{:#}", path.print()))); + return Generic(Symbol::intern(&format!("{:#}", path.print(&cx.cache)))); } Res::SelfTy(..) | Res::Def(DefKind::TyParam | DefKind::AssocTy, _) => true, _ => false, diff --git a/src/librustdoc/config.rs b/src/librustdoc/config.rs index fee1bf4c3a6a7..94773ac77ccb0 100644 --- a/src/librustdoc/config.rs +++ b/src/librustdoc/config.rs @@ -261,7 +261,7 @@ crate struct RenderOptions { } /// Temporary storage for data obtained during `RustdocVisitor::clean()`. -/// Later on moved into `CACHE_KEY`. +/// Later on moved into `cache`. #[derive(Default, Clone)] crate struct RenderInfo { crate inlined: FxHashSet, diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs index 4db5a0bccc85d..16f11e460e6f0 100644 --- a/src/librustdoc/core.rs +++ b/src/librustdoc/core.rs @@ -32,6 +32,7 @@ use crate::clean; use crate::clean::{AttributesExt, MAX_DEF_ID}; use crate::config::{Options as RustdocOptions, RenderOptions}; use crate::config::{OutputFormat, RenderInfo}; +use crate::formats::cache::Cache; use crate::passes::{self, Condition::*, ConditionalPass}; crate use rustc_session::config::{DebuggingOptions, Input, Options}; @@ -45,9 +46,9 @@ crate struct DocContext<'tcx> { /// /// Most of this logic is copied from rustc_lint::late. crate param_env: Cell>, - /// Later on moved into `CACHE_KEY` + /// Later on moved into `cache` crate renderinfo: RefCell, - /// Later on moved through `clean::Crate` into `CACHE_KEY` + /// Later on moved through `clean::Crate` into `cache` crate external_traits: Rc>>, /// Used while populating `external_traits` to ensure we don't process the same trait twice at /// the same time. @@ -75,6 +76,8 @@ crate struct DocContext<'tcx> { /// See `collect_intra_doc_links::traits_implemented_by` for more details. /// `map>` crate module_trait_cache: RefCell>>, + /// Fake empty cache used when cache is required as parameter. + crate cache: Cache, } impl<'tcx> DocContext<'tcx> { @@ -524,6 +527,7 @@ crate fn run_global_ctxt( .collect(), render_options, module_trait_cache: RefCell::new(FxHashMap::default()), + cache: Cache::default(), }; debug!("crate: {:?}", tcx.hir().krate()); diff --git a/src/librustdoc/formats/cache.rs b/src/librustdoc/formats/cache.rs index c1f8b12cac497..c506f5a37b15b 100644 --- a/src/librustdoc/formats/cache.rs +++ b/src/librustdoc/formats/cache.rs @@ -1,8 +1,6 @@ -use std::cell::RefCell; use std::collections::BTreeMap; use std::mem; use std::path::{Path, PathBuf}; -use std::sync::Arc; use rustc_data_structures::fx::{FxHashMap, FxHashSet}; use rustc_hir::def_id::{CrateNum, DefId, CRATE_DEF_INDEX}; @@ -19,8 +17,6 @@ use crate::html::markdown::short_markdown_summary; use crate::html::render::cache::{extern_location, get_index_search_type, ExternalLocation}; use crate::html::render::IndexItem; -thread_local!(crate static CACHE_KEY: RefCell> = Default::default()); - /// This cache is used to store information about the [`clean::Crate`] being /// rendered in order to provide more useful documentation. This contains /// information like all implementors of a trait, all traits a type implements, @@ -197,6 +193,7 @@ impl Cache { } cache.stack.push(krate.name.to_string()); + krate = cache.fold_crate(krate); for (trait_did, dids, impl_) in cache.orphan_trait_impls.drain(..) { @@ -319,7 +316,7 @@ impl DocFolder for Cache { .map_or_else(String::new, |x| short_markdown_summary(&x.as_str())), parent, parent_idx: None, - search_type: get_index_search_type(&item), + search_type: get_index_search_type(&item, None), }); for alias in item.attrs.get_doc_aliases() { @@ -477,7 +474,3 @@ impl DocFolder for Cache { ret } } - -crate fn cache() -> Arc { - CACHE_KEY.with(|c| c.borrow().clone()) -} diff --git a/src/librustdoc/formats/mod.rs b/src/librustdoc/formats/mod.rs index 58b9f5fbf0f6c..1ce6572bbed04 100644 --- a/src/librustdoc/formats/mod.rs +++ b/src/librustdoc/formats/mod.rs @@ -8,6 +8,7 @@ use rustc_span::def_id::DefId; use crate::clean; use crate::clean::types::GetDefId; +use crate::formats::cache::Cache; /// Specifies whether rendering directly implemented trait items or ones from a certain Deref /// impl. @@ -41,4 +42,8 @@ impl Impl { crate fn trait_did(&self) -> Option { self.inner_impl().trait_.def_id() } + + crate fn trait_did_full(&self, cache: &Cache) -> Option { + self.inner_impl().trait_.def_id_full(cache) + } } diff --git a/src/librustdoc/formats/renderer.rs b/src/librustdoc/formats/renderer.rs index 6941fa064ec03..6ecc4695dc8fb 100644 --- a/src/librustdoc/formats/renderer.rs +++ b/src/librustdoc/formats/renderer.rs @@ -1,12 +1,10 @@ -use std::sync::Arc; - use rustc_middle::ty::TyCtxt; use rustc_span::edition::Edition; use crate::clean; use crate::config::{RenderInfo, RenderOptions}; use crate::error::Error; -use crate::formats::cache::{Cache, CACHE_KEY}; +use crate::formats::cache::Cache; /// Allows for different backends to rustdoc to be used with the `run_format()` function. Each /// backend renderer has hooks for initialization, documenting an item, entering and exiting a @@ -22,20 +20,15 @@ crate trait FormatRenderer<'tcx>: Clone { options: RenderOptions, render_info: RenderInfo, edition: Edition, - cache: &mut Cache, + cache: Cache, tcx: TyCtxt<'tcx>, ) -> Result<(Self, clean::Crate), Error>; /// Renders a single non-module item. This means no recursive sub-item rendering is required. - fn item(&mut self, item: clean::Item, cache: &Cache) -> Result<(), Error>; + fn item(&mut self, item: clean::Item) -> Result<(), Error>; /// Renders a module (should not handle recursing into children). - fn mod_item_in( - &mut self, - item: &clean::Item, - item_name: &str, - cache: &Cache, - ) -> Result<(), Error>; + fn mod_item_in(&mut self, item: &clean::Item, item_name: &str) -> Result<(), Error>; /// Runs after recursively rendering all sub-items of a module. fn mod_item_out(&mut self, item_name: &str) -> Result<(), Error>; @@ -46,9 +39,10 @@ crate trait FormatRenderer<'tcx>: Clone { fn after_krate( &mut self, krate: &clean::Crate, - cache: &Cache, diag: &rustc_errors::Handler, ) -> Result<(), Error>; + + fn cache(&self) -> &Cache; } /// Main method for rendering a crate. @@ -60,7 +54,7 @@ crate fn run_format<'tcx, T: FormatRenderer<'tcx>>( edition: Edition, tcx: TyCtxt<'tcx>, ) -> Result<(), Error> { - let (krate, mut cache) = tcx.sess.time("create_format_cache", || { + let (krate, cache) = tcx.sess.time("create_format_cache", || { Cache::from_krate( render_info.clone(), options.document_private, @@ -73,12 +67,7 @@ crate fn run_format<'tcx, T: FormatRenderer<'tcx>>( let (mut format_renderer, mut krate) = prof .extra_verbose_generic_activity("create_renderer", T::descr()) - .run(|| T::init(krate, options, render_info, edition, &mut cache, tcx))?; - - let cache = Arc::new(cache); - // Freeze the cache now that the index has been built. Put an Arc into TLS for future - // parallelization opportunities - CACHE_KEY.with(|v| *v.borrow_mut() = cache.clone()); + .run(|| T::init(krate, options, render_info, edition, cache, tcx))?; let mut item = match krate.module.take() { Some(i) => i, @@ -101,7 +90,7 @@ crate fn run_format<'tcx, T: FormatRenderer<'tcx>>( } let _timer = prof.generic_activity_with_arg("render_mod_item", name.as_str()); - cx.mod_item_in(&item, &name, &cache)?; + cx.mod_item_in(&item, &name)?; let module = match *item.kind { clean::StrippedItem(box clean::ModuleItem(m)) | clean::ModuleItem(m) => m, _ => unreachable!(), @@ -114,9 +103,9 @@ crate fn run_format<'tcx, T: FormatRenderer<'tcx>>( cx.mod_item_out(&name)?; } else if item.name.is_some() { prof.generic_activity_with_arg("render_item", &*item.name.unwrap_or(unknown).as_str()) - .run(|| cx.item(item, &cache))?; + .run(|| cx.item(item))?; } } prof.extra_verbose_generic_activity("renderer_after_krate", T::descr()) - .run(|| format_renderer.after_krate(&krate, &cache, diag)) + .run(|| format_renderer.after_krate(&krate, diag)) } diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs index 5c2adca3126f7..01915c33a07ad 100644 --- a/src/librustdoc/html/format.rs +++ b/src/librustdoc/html/format.rs @@ -16,7 +16,7 @@ use rustc_span::def_id::{DefId, CRATE_DEF_INDEX}; use rustc_target::spec::abi::Abi; use crate::clean::{self, utils::find_nearest_parent_module, PrimitiveType}; -use crate::formats::cache::cache; +use crate::formats::cache::Cache; use crate::formats::item_type::ItemType; use crate::html::escape::Escape; use crate::html::render::cache::ExternalLocation; @@ -152,24 +152,27 @@ fn comma_sep(items: impl Iterator) -> impl fmt::Displ }) } -crate fn print_generic_bounds(bounds: &[clean::GenericBound]) -> impl fmt::Display + '_ { +crate fn print_generic_bounds<'a>( + bounds: &'a [clean::GenericBound], + cache: &'a Cache, +) -> impl fmt::Display + 'a { display_fn(move |f| { let mut bounds_dup = FxHashSet::default(); for (i, bound) in - bounds.iter().filter(|b| bounds_dup.insert(b.print().to_string())).enumerate() + bounds.iter().filter(|b| bounds_dup.insert(b.print(cache).to_string())).enumerate() { if i > 0 { f.write_str(" + ")?; } - fmt::Display::fmt(&bound.print(), f)?; + fmt::Display::fmt(&bound.print(cache), f)?; } Ok(()) }) } impl clean::GenericParamDef { - crate fn print(&self) -> impl fmt::Display + '_ { + crate fn print<'a>(&'a self, cache: &'a Cache) -> impl fmt::Display + 'a { display_fn(move |f| match self.kind { clean::GenericParamDefKind::Lifetime => write!(f, "{}", self.name), clean::GenericParamDefKind::Type { ref bounds, ref default, .. } => { @@ -177,17 +180,17 @@ impl clean::GenericParamDef { if !bounds.is_empty() { if f.alternate() { - write!(f, ": {:#}", print_generic_bounds(bounds))?; + write!(f, ": {:#}", print_generic_bounds(bounds, cache))?; } else { - write!(f, ": {}", print_generic_bounds(bounds))?; + write!(f, ": {}", print_generic_bounds(bounds, cache))?; } } if let Some(ref ty) = default { if f.alternate() { - write!(f, " = {:#}", ty.print())?; + write!(f, " = {:#}", ty.print(cache))?; } else { - write!(f, " = {}", ty.print())?; + write!(f, " = {}", ty.print(cache))?; } } @@ -195,9 +198,9 @@ impl clean::GenericParamDef { } clean::GenericParamDefKind::Const { ref ty, .. } => { if f.alternate() { - write!(f, "const {}: {:#}", self.name, ty.print()) + write!(f, "const {}: {:#}", self.name, ty.print(cache)) } else { - write!(f, "const {}: {}", self.name, ty.print()) + write!(f, "const {}: {}", self.name, ty.print(cache)) } } }) @@ -205,7 +208,7 @@ impl clean::GenericParamDef { } impl clean::Generics { - crate fn print(&self) -> impl fmt::Display + '_ { + crate fn print<'a>(&'a self, cache: &'a Cache) -> impl fmt::Display + 'a { display_fn(move |f| { let real_params = self.params.iter().filter(|p| !p.is_synthetic_type_param()).collect::>(); @@ -213,98 +216,108 @@ impl clean::Generics { return Ok(()); } if f.alternate() { - write!(f, "<{:#}>", comma_sep(real_params.iter().map(|g| g.print()))) + write!(f, "<{:#}>", comma_sep(real_params.iter().map(|g| g.print(cache)))) } else { - write!(f, "<{}>", comma_sep(real_params.iter().map(|g| g.print()))) + write!(f, "<{}>", comma_sep(real_params.iter().map(|g| g.print(cache)))) } }) } } -impl<'a> fmt::Display for WhereClause<'a> { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - let &WhereClause { gens, indent, end_newline } = self; - if gens.where_predicates.is_empty() { - return Ok(()); - } - let mut clause = String::new(); - if f.alternate() { - clause.push_str(" where"); - } else { - if end_newline { - clause.push_str(" where"); - } else { - clause.push_str(" where"); +impl<'a> WhereClause<'a> { + crate fn print<'b>(&'b self, cache: &'b Cache) -> impl fmt::Display + 'b { + display_fn(move |f| { + let &WhereClause { gens, indent, end_newline } = self; + if gens.where_predicates.is_empty() { + return Ok(()); } - } - for (i, pred) in gens.where_predicates.iter().enumerate() { + let mut clause = String::new(); if f.alternate() { - clause.push(' '); + clause.push_str(" where"); } else { - clause.push_str("
"); + if end_newline { + clause.push_str(" where"); + } else { + clause.push_str(" where"); + } } + for (i, pred) in gens.where_predicates.iter().enumerate() { + if f.alternate() { + clause.push(' '); + } else { + clause.push_str("
"); + } - match pred { - clean::WherePredicate::BoundPredicate { ty, bounds } => { - let bounds = bounds; - if f.alternate() { - clause.push_str(&format!( - "{:#}: {:#}", - ty.print(), - print_generic_bounds(bounds) - )); - } else { + match pred { + clean::WherePredicate::BoundPredicate { ty, bounds } => { + let bounds = bounds; + if f.alternate() { + clause.push_str(&format!( + "{:#}: {:#}", + ty.print(cache), + print_generic_bounds(bounds, cache) + )); + } else { + clause.push_str(&format!( + "{}: {}", + ty.print(cache), + print_generic_bounds(bounds, cache) + )); + } + } + clean::WherePredicate::RegionPredicate { lifetime, bounds } => { clause.push_str(&format!( "{}: {}", - ty.print(), - print_generic_bounds(bounds) + lifetime.print(), + bounds + .iter() + .map(|b| b.print(cache).to_string()) + .collect::>() + .join(" + ") )); } - } - clean::WherePredicate::RegionPredicate { lifetime, bounds } => { - clause.push_str(&format!( - "{}: {}", - lifetime.print(), - bounds - .iter() - .map(|b| b.print().to_string()) - .collect::>() - .join(" + ") - )); - } - clean::WherePredicate::EqPredicate { lhs, rhs } => { - if f.alternate() { - clause.push_str(&format!("{:#} == {:#}", lhs.print(), rhs.print())); - } else { - clause.push_str(&format!("{} == {}", lhs.print(), rhs.print())); + clean::WherePredicate::EqPredicate { lhs, rhs } => { + if f.alternate() { + clause.push_str(&format!( + "{:#} == {:#}", + lhs.print(cache), + rhs.print(cache) + )); + } else { + clause.push_str(&format!( + "{} == {}", + lhs.print(cache), + rhs.print(cache) + )); + } } } - } - if i < gens.where_predicates.len() - 1 || end_newline { - clause.push(','); + if i < gens.where_predicates.len() - 1 || end_newline { + clause.push(','); + } } - } - if end_newline { - // add a space so stripping
tags and breaking spaces still renders properly - if f.alternate() { - clause.push(' '); - } else { - clause.push_str(" "); + if end_newline { + // add a space so stripping
tags and breaking spaces still renders properly + if f.alternate() { + clause.push(' '); + } else { + clause.push_str(" "); + } } - } - if !f.alternate() { - clause.push_str(""); - let padding = " ".repeat(indent + 4); - clause = clause.replace("
", &format!("
{}", padding)); - clause.insert_str(0, &" ".repeat(indent.saturating_sub(1))); - if !end_newline { - clause.insert_str(0, "
"); + if !f.alternate() { + clause.push_str(""); + let padding = " ".repeat(indent + 4); + clause = clause.replace("
", &format!("
{}", padding)); + clause.insert_str(0, &" ".repeat(indent.saturating_sub(1))); + if !end_newline { + clause.insert_str(0, "
"); + } } - } - write!(f, "{}", clause) + write!(f, "{}", clause) + }) } } @@ -327,34 +340,34 @@ impl clean::Constant { } impl clean::PolyTrait { - fn print(&self) -> impl fmt::Display + '_ { + fn print<'a>(&'a self, cache: &'a Cache) -> impl fmt::Display + 'a { 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())) + comma_sep(self.generic_params.iter().map(|g| g.print(cache))) )?; } else { write!( f, "for<{}> ", - comma_sep(self.generic_params.iter().map(|g| g.print())) + comma_sep(self.generic_params.iter().map(|g| g.print(cache))) )?; } } if f.alternate() { - write!(f, "{:#}", self.trait_.print()) + write!(f, "{:#}", self.trait_.print(cache)) } else { - write!(f, "{}", self.trait_.print()) + write!(f, "{}", self.trait_.print(cache)) } }) } } impl clean::GenericBound { - crate fn print(&self) -> impl fmt::Display + '_ { + crate fn print<'a>(&'a self, cache: &'a Cache) -> impl fmt::Display + 'a { display_fn(move |f| match self { clean::GenericBound::Outlives(lt) => write!(f, "{}", lt.print()), clean::GenericBound::TraitBound(ty, modifier) => { @@ -364,9 +377,9 @@ impl clean::GenericBound { hir::TraitBoundModifier::MaybeConst => "?const", }; if f.alternate() { - write!(f, "{}{:#}", modifier_str, ty.print()) + write!(f, "{}{:#}", modifier_str, ty.print(cache)) } else { - write!(f, "{}{}", modifier_str, ty.print()) + write!(f, "{}{}", modifier_str, ty.print(cache)) } } }) @@ -374,7 +387,7 @@ impl clean::GenericBound { } impl clean::GenericArgs { - fn print(&self) -> impl fmt::Display + '_ { + fn print<'a>(&'a self, cache: &'a Cache) -> impl fmt::Display + 'a { display_fn(move |f| { match self { clean::GenericArgs::AngleBracketed { args, bindings } => { @@ -391,9 +404,9 @@ impl clean::GenericArgs { } comma = true; if f.alternate() { - write!(f, "{:#}", arg.print())?; + write!(f, "{:#}", arg.print(cache))?; } else { - write!(f, "{}", arg.print())?; + write!(f, "{}", arg.print(cache))?; } } for binding in bindings { @@ -402,9 +415,9 @@ impl clean::GenericArgs { } comma = true; if f.alternate() { - write!(f, "{:#}", binding.print())?; + write!(f, "{:#}", binding.print(cache))?; } else { - write!(f, "{}", binding.print())?; + write!(f, "{}", binding.print(cache))?; } } if f.alternate() { @@ -423,17 +436,17 @@ impl clean::GenericArgs { } comma = true; if f.alternate() { - write!(f, "{:#}", ty.print())?; + write!(f, "{:#}", ty.print(cache))?; } else { - write!(f, "{}", ty.print())?; + write!(f, "{}", ty.print(cache))?; } } f.write_str(")")?; if let Some(ref ty) = *output { if f.alternate() { - write!(f, " -> {:#}", ty.print())?; + write!(f, " -> {:#}", ty.print(cache))?; } else { - write!(f, " -> {}", ty.print())?; + write!(f, " -> {}", ty.print(cache))?; } } } @@ -444,19 +457,19 @@ impl clean::GenericArgs { } impl clean::PathSegment { - crate fn print(&self) -> impl fmt::Display + '_ { + crate fn print<'a>(&'a self, cache: &'a Cache) -> impl fmt::Display + 'a { display_fn(move |f| { if f.alternate() { - write!(f, "{}{:#}", self.name, self.args.print()) + write!(f, "{}{:#}", self.name, self.args.print(cache)) } else { - write!(f, "{}{}", self.name, self.args.print()) + write!(f, "{}{}", self.name, self.args.print(cache)) } }) } } impl clean::Path { - crate fn print(&self) -> impl fmt::Display + '_ { + crate fn print<'a>(&'a self, cache: &'a Cache) -> impl fmt::Display + 'a { display_fn(move |f| { if self.global { f.write_str("::")? @@ -467,9 +480,9 @@ impl clean::Path { f.write_str("::")? } if f.alternate() { - write!(f, "{:#}", seg.print())?; + write!(f, "{:#}", seg.print(cache))?; } else { - write!(f, "{}", seg.print())?; + write!(f, "{}", seg.print(cache))?; } } Ok(()) @@ -477,8 +490,7 @@ impl clean::Path { } } -crate fn href(did: DefId) -> Option<(String, ItemType, Vec)> { - let cache = cache(); +crate fn href(did: DefId, cache: &Cache) -> Option<(String, ItemType, Vec)> { if !did.is_local() && !cache.access_levels.is_public(did) && !cache.document_private { return None; } @@ -526,6 +538,7 @@ fn resolved_path( path: &clean::Path, print_all: bool, use_absolute: bool, + cache: &Cache, ) -> fmt::Result { let last = path.segments.last().unwrap(); @@ -535,18 +548,22 @@ fn resolved_path( } } if w.alternate() { - write!(w, "{}{:#}", &last.name, last.args.print())?; + write!(w, "{}{:#}", &last.name, last.args.print(cache))?; } else { let path = if use_absolute { - if let Some((_, _, fqp)) = href(did) { - format!("{}::{}", fqp[..fqp.len() - 1].join("::"), anchor(did, fqp.last().unwrap())) + if let Some((_, _, fqp)) = href(did, cache) { + format!( + "{}::{}", + fqp[..fqp.len() - 1].join("::"), + anchor(did, fqp.last().unwrap(), cache) + ) } else { last.name.to_string() } } else { - anchor(did, &*last.name.as_str()).to_string() + anchor(did, &*last.name.as_str(), cache).to_string() }; - write!(w, "{}{}", path, last.args.print())?; + write!(w, "{}{}", path, last.args.print(cache))?; } Ok(()) } @@ -555,8 +572,8 @@ fn primitive_link( f: &mut fmt::Formatter<'_>, prim: clean::PrimitiveType, name: &str, + m: &Cache, ) -> fmt::Result { - let m = cache(); let mut needs_termination = false; if !f.alternate() { match m.primitive_locations.get(&prim) { @@ -602,12 +619,15 @@ fn primitive_link( } /// Helper to render type parameters -fn tybounds(param_names: &Option>) -> impl fmt::Display + '_ { +fn tybounds<'a>( + param_names: &'a Option>, + cache: &'a Cache, +) -> impl fmt::Display + 'a { display_fn(move |f| match *param_names { Some(ref params) => { for param in params { write!(f, " + ")?; - fmt::Display::fmt(¶m.print(), f)?; + fmt::Display::fmt(¶m.print(cache), f)?; } Ok(()) } @@ -615,9 +635,9 @@ fn tybounds(param_names: &Option>) -> impl fmt::Display }) } -crate fn anchor(did: DefId, text: &str) -> impl fmt::Display + '_ { +crate fn anchor<'a>(did: DefId, text: &'a str, cache: &'a Cache) -> impl fmt::Display + 'a { display_fn(move |f| { - if let Some((url, short_ty, fqp)) = href(did) { + if let Some((url, short_ty, fqp)) = href(did, cache) { write!( f, r#"{}"#, @@ -633,7 +653,12 @@ crate fn anchor(did: DefId, text: &str) -> impl fmt::Display + '_ { }) } -fn fmt_type(t: &clean::Type, f: &mut fmt::Formatter<'_>, use_absolute: bool) -> fmt::Result { +fn fmt_type( + t: &clean::Type, + f: &mut fmt::Formatter<'_>, + use_absolute: bool, + cache: &Cache, +) -> fmt::Result { match *t { clean::Generic(name) => write!(f, "{}", name), clean::ResolvedPath { did, ref param_names, ref path, is_generic } => { @@ -641,11 +666,11 @@ fn fmt_type(t: &clean::Type, f: &mut fmt::Formatter<'_>, use_absolute: bool) -> f.write_str("dyn ")?; } // Paths like `T::Output` and `Self::Output` should be rendered with all segments. - resolved_path(f, did, path, is_generic, use_absolute)?; - fmt::Display::fmt(&tybounds(param_names), f) + resolved_path(f, did, path, is_generic, use_absolute, cache)?; + fmt::Display::fmt(&tybounds(param_names, cache), f) } clean::Infer => write!(f, "_"), - clean::Primitive(prim) => primitive_link(f, prim, prim.as_str()), + clean::Primitive(prim) => primitive_link(f, prim, prim.as_str(), cache), clean::BareFunction(ref decl) => { if f.alternate() { write!( @@ -653,8 +678,8 @@ fn fmt_type(t: &clean::Type, f: &mut fmt::Formatter<'_>, use_absolute: bool) -> "{}{:#}fn{:#}{:#}", decl.unsafety.print_with_space(), print_abi_with_space(decl.abi), - decl.print_generic_params(), - decl.decl.print() + decl.print_generic_params(cache), + decl.decl.print(cache) ) } else { write!( @@ -663,46 +688,46 @@ fn fmt_type(t: &clean::Type, f: &mut fmt::Formatter<'_>, use_absolute: bool) -> decl.unsafety.print_with_space(), print_abi_with_space(decl.abi) )?; - primitive_link(f, PrimitiveType::Fn, "fn")?; - write!(f, "{}{}", decl.print_generic_params(), decl.decl.print()) + primitive_link(f, PrimitiveType::Fn, "fn", cache)?; + write!(f, "{}{}", decl.print_generic_params(cache), decl.decl.print(cache)) } } clean::Tuple(ref typs) => { match &typs[..] { - &[] => primitive_link(f, PrimitiveType::Unit, "()"), + &[] => primitive_link(f, PrimitiveType::Unit, "()", cache), &[ref one] => { - primitive_link(f, PrimitiveType::Tuple, "(")?; + primitive_link(f, PrimitiveType::Tuple, "(", cache)?; // Carry `f.alternate()` into this display w/o branching manually. - fmt::Display::fmt(&one.print(), f)?; - primitive_link(f, PrimitiveType::Tuple, ",)") + fmt::Display::fmt(&one.print(cache), f)?; + primitive_link(f, PrimitiveType::Tuple, ",)", cache) } many => { - primitive_link(f, PrimitiveType::Tuple, "(")?; + primitive_link(f, PrimitiveType::Tuple, "(", cache)?; for (i, item) in many.iter().enumerate() { if i != 0 { write!(f, ", ")?; } - fmt::Display::fmt(&item.print(), f)?; + fmt::Display::fmt(&item.print(cache), f)?; } - primitive_link(f, PrimitiveType::Tuple, ")") + primitive_link(f, PrimitiveType::Tuple, ")", cache) } } } clean::Slice(ref t) => { - primitive_link(f, PrimitiveType::Slice, "[")?; - fmt::Display::fmt(&t.print(), f)?; - primitive_link(f, PrimitiveType::Slice, "]") + primitive_link(f, PrimitiveType::Slice, "[", cache)?; + fmt::Display::fmt(&t.print(cache), f)?; + primitive_link(f, PrimitiveType::Slice, "]", cache) } clean::Array(ref t, ref n) => { - primitive_link(f, PrimitiveType::Array, "[")?; - fmt::Display::fmt(&t.print(), f)?; + primitive_link(f, PrimitiveType::Array, "[", cache)?; + fmt::Display::fmt(&t.print(cache), f)?; if f.alternate() { - primitive_link(f, PrimitiveType::Array, &format!("; {}]", n)) + primitive_link(f, PrimitiveType::Array, &format!("; {}]", n), cache) } else { - primitive_link(f, PrimitiveType::Array, &format!("; {}]", Escape(n))) + primitive_link(f, PrimitiveType::Array, &format!("; {}]", Escape(n)), cache) } } - clean::Never => primitive_link(f, PrimitiveType::Never, "!"), + clean::Never => primitive_link(f, PrimitiveType::Never, "!", cache), clean::RawPointer(m, ref t) => { let m = match m { hir::Mutability::Mut => "mut", @@ -714,19 +739,26 @@ fn fmt_type(t: &clean::Type, f: &mut fmt::Formatter<'_>, use_absolute: bool) -> primitive_link( f, clean::PrimitiveType::RawPointer, - &format!("*{} {:#}", m, t.print()), + &format!("*{} {:#}", m, t.print(cache)), + cache, ) } else { primitive_link( f, clean::PrimitiveType::RawPointer, - &format!("*{} {}", m, t.print()), + &format!("*{} {}", m, t.print(cache)), + cache, ) } } _ => { - primitive_link(f, clean::PrimitiveType::RawPointer, &format!("*{} ", m))?; - fmt::Display::fmt(&t.print(), f) + primitive_link( + f, + clean::PrimitiveType::RawPointer, + &format!("*{} ", m), + cache, + )?; + fmt::Display::fmt(&t.print(cache), f) } } } @@ -746,13 +778,15 @@ fn fmt_type(t: &clean::Type, f: &mut fmt::Formatter<'_>, use_absolute: bool) -> primitive_link( f, PrimitiveType::Slice, - &format!("{}{}{}[{:#}]", amp, lt, m, bt.print()), + &format!("{}{}{}[{:#}]", amp, lt, m, bt.print(cache)), + cache, ) } else { primitive_link( f, PrimitiveType::Slice, - &format!("{}{}{}[{}]", amp, lt, m, bt.print()), + &format!("{}{}{}[{}]", amp, lt, m, bt.print(cache)), + cache, ) } } @@ -761,36 +795,42 @@ fn fmt_type(t: &clean::Type, f: &mut fmt::Formatter<'_>, use_absolute: bool) -> f, PrimitiveType::Slice, &format!("{}{}{}[", amp, lt, m), + cache, )?; if f.alternate() { - write!(f, "{:#}", bt.print())?; + write!(f, "{:#}", bt.print(cache))?; } else { - write!(f, "{}", bt.print())?; + write!(f, "{}", bt.print(cache))?; } - primitive_link(f, PrimitiveType::Slice, "]") + primitive_link(f, PrimitiveType::Slice, "]", cache) } } } clean::ResolvedPath { param_names: Some(ref v), .. } if !v.is_empty() => { write!(f, "{}{}{}(", amp, lt, m)?; - fmt_type(&ty, f, use_absolute)?; + fmt_type(&ty, f, use_absolute, cache)?; write!(f, ")") } clean::Generic(..) => { - primitive_link(f, PrimitiveType::Reference, &format!("{}{}{}", amp, lt, m))?; - fmt_type(&ty, f, use_absolute) + primitive_link( + f, + PrimitiveType::Reference, + &format!("{}{}{}", amp, lt, m), + cache, + )?; + fmt_type(&ty, f, use_absolute, cache) } _ => { write!(f, "{}{}{}", amp, lt, m)?; - fmt_type(&ty, f, use_absolute) + fmt_type(&ty, f, use_absolute, cache) } } } clean::ImplTrait(ref bounds) => { if f.alternate() { - write!(f, "impl {:#}", print_generic_bounds(bounds)) + write!(f, "impl {:#}", print_generic_bounds(bounds, cache)) } else { - write!(f, "impl {}", print_generic_bounds(bounds)) + write!(f, "impl {}", print_generic_bounds(bounds, cache)) } } clean::QPath { ref name, ref self_type, ref trait_ } => { @@ -802,15 +842,15 @@ fn fmt_type(t: &clean::Type, f: &mut fmt::Formatter<'_>, use_absolute: bool) -> }; if f.alternate() { if should_show_cast { - write!(f, "<{:#} as {:#}>::", self_type.print(), trait_.print())? + write!(f, "<{:#} as {:#}>::", self_type.print(cache), trait_.print(cache))? } else { - write!(f, "{:#}::", self_type.print())? + write!(f, "{:#}::", self_type.print(cache))? } } else { if should_show_cast { - write!(f, "<{} as {}>::", self_type.print(), trait_.print())? + write!(f, "<{} as {}>::", self_type.print(cache), trait_.print(cache))? } else { - write!(f, "{}::", self_type.print())? + write!(f, "{}::", self_type.print(cache))? } }; match *trait_ { @@ -825,7 +865,7 @@ fn fmt_type(t: &clean::Type, f: &mut fmt::Formatter<'_>, use_absolute: bool) -> // everything comes in as a fully resolved QPath (hard to // look at). box clean::ResolvedPath { did, ref param_names, .. } => { - match href(did) { + match href(did, cache) { Some((ref url, _, ref path)) if !f.alternate() => { write!( f, @@ -851,22 +891,27 @@ fn fmt_type(t: &clean::Type, f: &mut fmt::Formatter<'_>, use_absolute: bool) -> } impl clean::Type { - crate fn print(&self) -> impl fmt::Display + '_ { - display_fn(move |f| fmt_type(self, f, false)) + crate fn print<'b, 'a: 'b>(&'a self, cache: &'b Cache) -> impl fmt::Display + 'b { + display_fn(move |f| fmt_type(self, f, false, cache)) } } impl clean::Impl { - crate fn print(&self) -> impl fmt::Display + '_ { - self.print_inner(true, false) + crate fn print<'a>(&'a self, cache: &'a Cache) -> impl fmt::Display + 'a { + self.print_inner(true, false, cache) } - fn print_inner(&self, link_trait: bool, use_absolute: bool) -> impl fmt::Display + '_ { + fn print_inner<'a>( + &'a self, + link_trait: bool, + use_absolute: bool, + cache: &'a Cache, + ) -> impl fmt::Display + 'a { display_fn(move |f| { if f.alternate() { - write!(f, "impl{:#} ", self.generics.print())?; + write!(f, "impl{:#} ", self.generics.print(cache))?; } else { - write!(f, "impl{} ", self.generics.print())?; + write!(f, "impl{} ", self.generics.print(cache))?; } if let Some(ref ty) = self.trait_ { @@ -875,7 +920,7 @@ impl clean::Impl { } if link_trait { - fmt::Display::fmt(&ty.print(), f)?; + fmt::Display::fmt(&ty.print(cache), f)?; } else { match ty { clean::ResolvedPath { @@ -883,7 +928,7 @@ impl clean::Impl { } => { let last = path.segments.last().unwrap(); fmt::Display::fmt(&last.name, f)?; - fmt::Display::fmt(&last.args.print(), f)?; + fmt::Display::fmt(&last.args.print(cache), f)?; } _ => unreachable!(), } @@ -892,36 +937,39 @@ impl clean::Impl { } if let Some(ref ty) = self.blanket_impl { - fmt_type(ty, f, use_absolute)?; + fmt_type(ty, f, use_absolute, cache)?; } else { - fmt_type(&self.for_, f, use_absolute)?; + fmt_type(&self.for_, f, use_absolute, cache)?; } - fmt::Display::fmt( - &WhereClause { gens: &self.generics, indent: 0, end_newline: true }, - f, - )?; + let where_clause = WhereClause { gens: &self.generics, indent: 0, end_newline: true }; + fmt::Display::fmt(&where_clause.print(cache), f)?; Ok(()) }) } } // The difference from above is that trait is not hyperlinked. -crate fn fmt_impl_for_trait_page(i: &clean::Impl, f: &mut Buffer, use_absolute: bool) { - f.from_display(i.print_inner(false, use_absolute)) +crate fn fmt_impl_for_trait_page( + i: &clean::Impl, + f: &mut Buffer, + use_absolute: bool, + cache: &Cache, +) { + f.from_display(i.print_inner(false, use_absolute, cache)) } impl clean::Arguments { - crate fn print(&self) -> impl fmt::Display + '_ { + crate fn print<'a>(&'a self, cache: &'a Cache) -> impl fmt::Display + 'a { 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())?; + write!(f, "{:#}", input.type_.print(cache))?; } else { - write!(f, "{}", input.type_.print())?; + write!(f, "{}", input.type_.print(cache))?; } if i + 1 < self.values.len() { write!(f, ", ")?; @@ -933,41 +981,41 @@ impl clean::Arguments { } impl clean::FnRetTy { - crate fn print(&self) -> impl fmt::Display + '_ { + crate fn print<'a>(&'a self, cache: &'a Cache) -> impl fmt::Display + 'a { 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()), - clean::Return(ty) => write!(f, " -> {}", ty.print()), + clean::Return(ty) if f.alternate() => write!(f, " -> {:#}", ty.print(cache)), + clean::Return(ty) => write!(f, " -> {}", ty.print(cache)), clean::DefaultReturn => Ok(()), }) } } impl clean::BareFunctionDecl { - fn print_generic_params(&self) -> impl fmt::Display + '_ { - comma_sep(self.generic_params.iter().map(|g| g.print())) + fn print_generic_params<'a>(&'a self, cache: &'a Cache) -> impl fmt::Display + 'a { + comma_sep(self.generic_params.iter().map(move |g| g.print(cache))) } } impl clean::FnDecl { - crate fn print(&self) -> impl fmt::Display + '_ { + crate fn print<'a>(&'a self, cache: &'a Cache) -> impl fmt::Display + 'a { display_fn(move |f| { let ellipsis = if self.c_variadic { ", ..." } else { "" }; if f.alternate() { write!( f, "({args:#}{ellipsis}){arrow:#}", - args = self.inputs.print(), + args = self.inputs.print(cache), ellipsis = ellipsis, - arrow = self.output.print() + arrow = self.output.print(cache) ) } else { write!( f, "({args}{ellipsis}){arrow}", - args = self.inputs.print(), + args = self.inputs.print(cache), ellipsis = ellipsis, - arrow = self.output.print() + arrow = self.output.print(cache) ) } }) @@ -975,7 +1023,7 @@ impl clean::FnDecl { } impl Function<'_> { - crate fn print(&self) -> impl fmt::Display + '_ { + crate fn print<'b, 'a: 'b>(&'a self, cache: &'b Cache) -> impl fmt::Display + 'b { display_fn(move |f| { let &Function { decl, header_len, indent, asyncness } = self; let amp = if f.alternate() { "&" } else { "&" }; @@ -1011,11 +1059,11 @@ impl Function<'_> { } clean::SelfExplicit(ref typ) => { if f.alternate() { - args.push_str(&format!("self: {:#}", typ.print())); + args.push_str(&format!("self: {:#}", typ.print(cache))); } else { - args.push_str(&format!("self: {}", typ.print())); + args.push_str(&format!("self: {}", typ.print(cache))); } - args_plain.push_str(&format!("self: {:#}", typ.print())); + args_plain.push_str(&format!("self: {:#}", typ.print(cache))); } } } else { @@ -1029,11 +1077,11 @@ impl Function<'_> { } if f.alternate() { - args.push_str(&format!("{:#}", input.type_.print())); + args.push_str(&format!("{:#}", input.type_.print(cache))); } else { - args.push_str(&input.type_.print().to_string()); + args.push_str(&input.type_.print(cache).to_string()); } - args_plain.push_str(&format!("{:#}", input.type_.print())); + args_plain.push_str(&format!("{:#}", input.type_.print(cache))); } if i + 1 < decl.inputs.values.len() { args.push(','); @@ -1054,11 +1102,11 @@ impl Function<'_> { Cow::Borrowed(&decl.output) }; - let arrow_plain = format!("{:#}", &output.print()); + let arrow_plain = format!("{:#}", &output.print(cache)); let arrow = if f.alternate() { - format!("{:#}", &output.print()) + format!("{:#}", &output.print(cache)) } else { - output.print().to_string() + output.print(cache).to_string() }; let declaration_len = header_len + args_plain.len() + arrow_plain.len(); @@ -1089,13 +1137,13 @@ impl clean::Visibility { self, tcx: TyCtxt<'tcx>, item_did: DefId, + cache: &Cache, ) -> impl fmt::Display + 'tcx { use rustc_span::symbol::kw; - display_fn(move |f| match self { - clean::Public => f.write_str("pub "), - clean::Inherited => Ok(()), - + 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 @@ -1103,38 +1151,41 @@ impl clean::Visibility { let parent_module = find_nearest_parent_module(tcx, item_did); if vis_did.index == CRATE_DEF_INDEX { - write!(f, "pub(crate) ") + "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 - Ok(()) + String::new() } else if parent_module .map(|parent| find_nearest_parent_module(tcx, parent)) .flatten() == Some(vis_did) { - write!(f, "pub(super) ") + "pub(super) ".to_owned() } else { - f.write_str("pub(")?; let path = tcx.def_path(vis_did); debug!("path={:?}", path); let first_name = path.data[0].data.get_opt_name().expect("modules are always named"); + // 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.as_str(), cache).to_string(); + + let mut s = "pub(".to_owned(); if path.data.len() != 1 || (first_name != kw::SelfLower && first_name != kw::Super) { - f.write_str("in ")?; + s.push_str("in "); } - // modified from `resolved_path()` to work with `DefPathData` - let last_name = path.data.last().unwrap().data.get_opt_name().unwrap(); for seg in &path.data[..path.data.len() - 1] { - write!(f, "{}::", seg.data.get_opt_name().unwrap())?; + s.push_str(&format!("{}::", seg.data.get_opt_name().unwrap())); } - let path = anchor(vis_did, &last_name.as_str()).to_string(); - write!(f, "{}) ", path) + s.push_str(&format!("{}) ", anchor)); + s } } - }) + }; + display_fn(move |f| f.write_str(&to_print)) } } @@ -1179,20 +1230,20 @@ impl PrintWithSpace for hir::Mutability { } impl clean::Import { - crate fn print(&self) -> impl fmt::Display + '_ { + crate fn print<'b, 'a: 'b>(&'a self, cache: &'b Cache) -> impl fmt::Display + 'b { display_fn(move |f| match self.kind { clean::ImportKind::Simple(name) => { if name == self.source.path.last() { - write!(f, "use {};", self.source.print()) + write!(f, "use {};", self.source.print(cache)) } else { - write!(f, "use {} as {};", self.source.print(), name) + write!(f, "use {} as {};", self.source.print(cache), name) } } clean::ImportKind::Glob => { if self.source.path.segments.is_empty() { write!(f, "use *;") } else { - write!(f, "use {}::*;", self.source.print()) + write!(f, "use {}::*;", self.source.print(cache)) } } }) @@ -1200,16 +1251,16 @@ impl clean::Import { } impl clean::ImportSource { - crate fn print(&self) -> impl fmt::Display + '_ { + crate fn print<'b, 'a: 'b>(&'a self, cache: &'b Cache) -> impl fmt::Display + 'b { display_fn(move |f| match self.did { - Some(did) => resolved_path(f, did, &self.path, true, false), + Some(did) => resolved_path(f, did, &self.path, true, false, cache), _ => { for seg in &self.path.segments[..self.path.segments.len() - 1] { write!(f, "{}::", seg.name)?; } let name = self.path.last_name(); if let hir::def::Res::PrimTy(p) = self.path.res { - primitive_link(f, PrimitiveType::from(p), &*name)?; + primitive_link(f, PrimitiveType::from(p), &*name, cache)?; } else { write!(f, "{}", name)?; } @@ -1220,23 +1271,23 @@ impl clean::ImportSource { } impl clean::TypeBinding { - crate fn print(&self) -> impl fmt::Display + '_ { + crate fn print<'b, 'a: 'b>(&'a self, cache: &'b Cache) -> impl fmt::Display + 'b { display_fn(move |f| { f.write_str(&*self.name.as_str())?; match self.kind { clean::TypeBindingKind::Equality { ref ty } => { if f.alternate() { - write!(f, " = {:#}", ty.print())?; + write!(f, " = {:#}", ty.print(cache))?; } else { - write!(f, " = {}", ty.print())?; + write!(f, " = {}", ty.print(cache))?; } } clean::TypeBindingKind::Constraint { ref bounds } => { if !bounds.is_empty() { if f.alternate() { - write!(f, ": {:#}", print_generic_bounds(bounds))?; + write!(f, ": {:#}", print_generic_bounds(bounds, cache))?; } else { - write!(f, ": {}", print_generic_bounds(bounds))?; + write!(f, ": {}", print_generic_bounds(bounds, cache))?; } } } @@ -1261,10 +1312,10 @@ crate fn print_default_space<'a>(v: bool) -> &'a str { } impl clean::GenericArg { - crate fn print(&self) -> impl fmt::Display + '_ { + crate fn print<'b, 'a: 'b>(&'a self, cache: &'b Cache) -> impl fmt::Display + 'b { display_fn(move |f| match self { clean::GenericArg::Lifetime(lt) => fmt::Display::fmt(<.print(), f), - clean::GenericArg::Type(ty) => fmt::Display::fmt(&ty.print(), f), + clean::GenericArg::Type(ty) => fmt::Display::fmt(&ty.print(cache), f), clean::GenericArg::Const(ct) => fmt::Display::fmt(&ct.print(), f), }) } diff --git a/src/librustdoc/html/render/cache.rs b/src/librustdoc/html/render/cache.rs index 497cbbb4250a6..5c02be14181ed 100644 --- a/src/librustdoc/html/render/cache.rs +++ b/src/librustdoc/html/render/cache.rs @@ -67,31 +67,31 @@ crate fn build_index(krate: &clean::Crate, cache: &mut Cache) -> String { let mut crate_items = Vec::with_capacity(cache.search_index.len()); let mut crate_paths = vec![]; - let Cache { ref mut search_index, ref orphan_impl_items, ref paths, ref mut aliases, .. } = - *cache; - // Attach all orphan items to the type's definition if the type // has since been learned. - for &(did, ref item) in orphan_impl_items { - if let Some(&(ref fqp, _)) = paths.get(&did) { - search_index.push(IndexItem { + for &(did, ref item) in &cache.orphan_impl_items { + if let Some(&(ref fqp, _)) = cache.paths.get(&did) { + cache.search_index.push(IndexItem { ty: item.type_(), name: item.name.unwrap().to_string(), path: fqp[..fqp.len() - 1].join("::"), desc: item.doc_value().map_or_else(String::new, |s| short_markdown_summary(&s)), parent: Some(did), parent_idx: None, - search_type: get_index_search_type(&item), + search_type: get_index_search_type(&item, None), }); for alias in item.attrs.get_doc_aliases() { - aliases + cache + .aliases .entry(alias.to_lowercase()) .or_insert(Vec::new()) - .push(search_index.len() - 1); + .push(cache.search_index.len() - 1); } } } + let Cache { ref mut search_index, ref paths, ref mut aliases, .. } = *cache; + // Reduce `DefId` in paths into smaller sequential numbers, // and prune the paths that do not appear in the index. let mut lastpath = String::new(); @@ -164,7 +164,10 @@ crate fn build_index(krate: &clean::Crate, cache: &mut Cache) -> String { ) } -crate fn get_index_search_type(item: &clean::Item) -> Option { +crate fn get_index_search_type( + item: &clean::Item, + cache: Option<&Cache>, +) -> Option { let (all_types, ret_types) = match *item.kind { clean::FunctionItem(ref f) => (&f.all_types, &f.ret_types), clean::MethodItem(ref m, _) => (&m.all_types, &m.ret_types), @@ -174,12 +177,12 @@ crate fn get_index_search_type(item: &clean::Item) -> Option>(); let output = if output.is_empty() { None } else { Some(output) }; @@ -187,12 +190,12 @@ crate fn get_index_search_type(item: &clean::Item) -> Option RenderType { +fn get_index_type(clean_type: &clean::Type, cache: &Option<&Cache>) -> RenderType { RenderType { - ty: clean_type.def_id(), + ty: cache.map_or_else(|| clean_type.def_id(), |cache| clean_type.def_id_full(cache)), idx: None, name: get_index_type_name(clean_type, true).map(|s| s.as_str().to_ascii_lowercase()), - generics: get_generics(clean_type), + generics: get_generics(clean_type, cache), } } @@ -216,14 +219,14 @@ fn get_index_type_name(clean_type: &clean::Type, accept_generic: bool) -> Option } } -fn get_generics(clean_type: &clean::Type) -> Option> { +fn get_generics(clean_type: &clean::Type, cache: &Option<&Cache>) -> Option> { clean_type.generics().and_then(|types| { let r = types .iter() .filter_map(|t| { get_index_type_name(t, false).map(|name| Generic { name: name.as_str().to_ascii_lowercase(), - defid: t.def_id(), + defid: cache.map_or_else(|| t.def_id(), |cache| t.def_id_full(cache)), idx: None, }) }) diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs index ef45c98e40629..bb9a7be590e87 100644 --- a/src/librustdoc/html/render/mod.rs +++ b/src/librustdoc/html/render/mod.rs @@ -69,7 +69,7 @@ use crate::clean::{self, AttributesExt, GetDefId, RenderedLink, SelfTy, TypeKind use crate::config::{RenderInfo, RenderOptions}; use crate::docfs::{DocFS, PathError}; use crate::error::Error; -use crate::formats::cache::{cache, Cache}; +use crate::formats::cache::Cache; use crate::formats::item_type::ItemType; use crate::formats::{AssocItemRender, FormatRenderer, Impl, RenderMode}; use crate::html::escape::Escape; @@ -122,6 +122,7 @@ crate struct Context<'tcx> { /// Storage for the errors produced while generating documentation so they /// can be printed together at the end. crate errors: Rc>, + crate cache: Rc, } crate struct SharedContext<'tcx> { @@ -392,7 +393,7 @@ impl<'tcx> FormatRenderer<'tcx> for Context<'tcx> { options: RenderOptions, _render_info: RenderInfo, edition: Edition, - cache: &mut Cache, + mut cache: Cache, tcx: TyCtxt<'tcx>, ) -> Result<(Self, clean::Crate), Error> { // need to save a copy of the options for rendering the index page @@ -503,9 +504,8 @@ impl<'tcx> FormatRenderer<'tcx> for Context<'tcx> { krate = sources::render(&dst, &mut scx, krate)?; // Build our search index - let index = build_index(&krate, cache); + let index = build_index(&krate, &mut cache); - let cache = Arc::new(cache); let mut cx = Context { current: Vec::new(), dst, @@ -515,13 +515,14 @@ impl<'tcx> FormatRenderer<'tcx> for Context<'tcx> { shared: Arc::new(scx), all: Rc::new(RefCell::new(AllTypes::new())), errors: Rc::new(receiver), + cache: Rc::new(cache), }; CURRENT_DEPTH.with(|s| s.set(0)); // Write shared runs within a flock; disable thread dispatching of IO temporarily. Arc::get_mut(&mut cx.shared).unwrap().fs.set_sync_only(true); - write_shared(&cx, &krate, index, &md_opts, &cache)?; + write_shared(&cx, &krate, index, &md_opts)?; Arc::get_mut(&mut cx.shared).unwrap().fs.set_sync_only(false); Ok((cx, krate)) } @@ -529,7 +530,6 @@ impl<'tcx> FormatRenderer<'tcx> for Context<'tcx> { fn after_krate( &mut self, krate: &clean::Crate, - cache: &Cache, diag: &rustc_errors::Handler, ) -> Result<(), Error> { let final_file = self.dst.join(&*krate.name.as_str()).join("all.html"); @@ -551,7 +551,7 @@ impl<'tcx> FormatRenderer<'tcx> for Context<'tcx> { extra_scripts: &[], static_extra_scripts: &[], }; - let sidebar = if let Some(ref version) = cache.crate_version { + let sidebar = if let Some(ref version) = self.cache.crate_version { format!( "

Crate {}

\
\ @@ -605,12 +605,7 @@ impl<'tcx> FormatRenderer<'tcx> for Context<'tcx> { } } - fn mod_item_in( - &mut self, - item: &clean::Item, - item_name: &str, - cache: &Cache, - ) -> Result<(), Error> { + fn mod_item_in(&mut self, item: &clean::Item, item_name: &str) -> 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. @@ -627,7 +622,7 @@ impl<'tcx> FormatRenderer<'tcx> for Context<'tcx> { info!("Recursing into {}", self.dst.display()); - let buf = self.render_item(item, false, cache); + let buf = self.render_item(item, false); // buf will be empty if the module is stripped and there is no redirect for it if !buf.is_empty() { self.shared.ensure_dir(&self.dst)?; @@ -658,7 +653,7 @@ impl<'tcx> FormatRenderer<'tcx> for Context<'tcx> { Ok(()) } - fn item(&mut self, item: clean::Item, cache: &Cache) -> Result<(), Error> { + 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. @@ -670,7 +665,7 @@ impl<'tcx> FormatRenderer<'tcx> for Context<'tcx> { self.render_redirect_pages = item.is_stripped(); } - let buf = self.render_item(&item, true, cache); + let buf = self.render_item(&item, true); // buf will be empty if the item is stripped and there is no redirect for it if !buf.is_empty() { let name = item.name.as_ref().unwrap(); @@ -694,6 +689,10 @@ impl<'tcx> FormatRenderer<'tcx> for Context<'tcx> { } Ok(()) } + + fn cache(&self) -> &Cache { + &self.cache + } } fn write_shared( @@ -701,7 +700,6 @@ fn write_shared( krate: &clean::Crate, search_index: String, options: &RenderOptions, - cache: &Cache, ) -> 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 @@ -1107,7 +1105,7 @@ themePicker.onblur = handleThemeButtonsBlur; // Update the list of all implementors for traits let dst = cx.dst.join("implementors"); - for (&did, imps) in &cache.implementors { + for (&did, imps) in &cx.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 @@ -1115,9 +1113,9 @@ themePicker.onblur = handleThemeButtonsBlur; // // FIXME: this is a vague explanation for why this can't be a `get`, in // theory it should be... - let &(ref remote_path, remote_item_type) = match cache.paths.get(&did) { + let &(ref remote_path, remote_item_type) = match cx.cache.paths.get(&did) { Some(p) => p, - None => match cache.external_paths.get(&did) { + None => match cx.cache.external_paths.get(&did) { Some(p) => p, None => continue, }, @@ -1144,9 +1142,9 @@ themePicker.onblur = handleThemeButtonsBlur; None } else { Some(Implementor { - text: imp.inner_impl().print().to_string(), + text: imp.inner_impl().print(cx.cache()).to_string(), synthetic: imp.inner_impl().synthetic, - types: collect_paths_for_type(imp.inner_impl().for_.clone()), + types: collect_paths_for_type(imp.inner_impl().for_.clone(), cx.cache()), }) } }) @@ -1155,7 +1153,7 @@ themePicker.onblur = handleThemeButtonsBlur; // 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) { + if implementors.is_empty() && !cx.cache.paths.contains_key(&did) { continue; } @@ -1214,8 +1212,8 @@ fn write_minify( } } -fn write_srclink(cx: &Context<'_>, item: &clean::Item, buf: &mut Buffer, cache: &Cache) { - if let Some(l) = cx.src_href(item, cache) { +fn write_srclink(cx: &Context<'_>, item: &clean::Item, buf: &mut Buffer) { + if let Some(l) = cx.src_href(item) { write!( buf, "[src]", @@ -1537,7 +1535,7 @@ impl Context<'_> { "../".repeat(self.current.len()) } - fn render_item(&self, it: &clean::Item, pushname: bool, cache: &Cache) -> String { + fn render_item(&self, it: &clean::Item, pushname: bool) -> String { // A little unfortunate that this is done like this, but it sure // does make formatting *a lot* nicer. CURRENT_DEPTH.with(|slot| { @@ -1590,13 +1588,13 @@ impl Context<'_> { layout::render( &self.shared.layout, &page, - |buf: &mut _| print_sidebar(self, it, buf, cache), - |buf: &mut _| print_item(self, it, buf, cache), + |buf: &mut _| print_sidebar(self, it, buf), + |buf: &mut _| print_item(self, it, buf), &self.shared.style_files, ) } else { let mut url = self.root_path(); - if let Some(&(ref names, ty)) = cache.paths.get(&it.def_id) { + if let Some(&(ref names, ty)) = self.cache.paths.get(&it.def_id) { for name in &names[..names.len() - 1] { url.push_str(name); url.push('/'); @@ -1647,7 +1645,7 @@ impl Context<'_> { /// 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. - fn src_href(&self, item: &clean::Item, cache: &Cache) -> Option { + fn src_href(&self, item: &clean::Item) -> Option { let mut root = self.root_path(); let mut path = String::new(); let cnum = item.source.cnum(self.sess()); @@ -1667,7 +1665,7 @@ impl Context<'_> { return None; } } else { - let (krate, src_root) = match *cache.extern_locations.get(&cnum)? { + let (krate, src_root) = match *self.cache.extern_locations.get(&cnum)? { (name, ref src, ExternalLocation::Local) => (name, src), (name, ref src, ExternalLocation::Remote(ref s)) => { root = s.to_string(); @@ -1710,7 +1708,7 @@ where write!(w, "
") } -fn print_item(cx: &Context<'_>, item: &clean::Item, buf: &mut Buffer, cache: &Cache) { +fn print_item(cx: &Context<'_>, item: &clean::Item, buf: &mut Buffer) { debug_assert!(!item.is_stripped()); // Write the breadcrumb trail header for the top write!(buf, "

"); @@ -1738,7 +1736,7 @@ fn print_item(cx: &Context<'_>, item: &clean::Item, buf: &mut Buffer, cache: &Ca // this page, and this link will be auto-clicked. The `id` attribute is // used to find the link to auto-click. if cx.shared.include_sources && !item.is_primitive() { - write_srclink(cx, item, buf, cache); + write_srclink(cx, item, buf); } write!(buf, ""); // out-of-band @@ -1797,20 +1795,20 @@ fn print_item(cx: &Context<'_>, item: &clean::Item, buf: &mut Buffer, cache: &Ca clean::FunctionItem(ref f) | clean::ForeignFunctionItem(ref f) => { item_function(buf, cx, item, f) } - clean::TraitItem(ref t) => item_trait(buf, cx, item, t, cache), - clean::StructItem(ref s) => item_struct(buf, cx, item, s, cache), - clean::UnionItem(ref s) => item_union(buf, cx, item, s, cache), - clean::EnumItem(ref e) => item_enum(buf, cx, item, e, cache), - clean::TypedefItem(ref t, _) => item_typedef(buf, cx, item, t, cache), + 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, cache), + 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, cache), + 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, cache), - clean::TraitAliasItem(ref ta) => item_trait_alias(buf, cx, item, ta, cache), + 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!(); @@ -1884,10 +1882,11 @@ fn document_short( return; } if let Some(s) = item.doc_value() { - let mut summary_html = MarkdownSummaryLine(&s, &item.links()).into_string(); + let mut summary_html = MarkdownSummaryLine(&s, &item.links(&cx.cache)).into_string(); if s.contains('\n') { - let link = format!(r#" Read more"#, naive_assoc_href(item, link)); + let link = + format!(r#" Read more"#, naive_assoc_href(item, link, cx.cache())); if let Some(idx) = summary_html.rfind("

") { summary_html.insert_str(idx, &link); @@ -1922,7 +1921,7 @@ fn document_full( ) { if let Some(s) = cx.shared.maybe_collapsed_doc_value(item) { debug!("Doc block: =====\n{}\n=====", s); - render_markdown(w, cx, &*s, item.links(), prefix, is_hidden); + render_markdown(w, cx, &*s, item.links(&cx.cache), prefix, is_hidden); } else if !prefix.is_empty() { write!( w, @@ -2161,15 +2160,15 @@ fn item_module(w: &mut Buffer, cx: &Context<'_>, item: &clean::Item, items: &[cl Some(ref src) => write!( w, "{}extern crate {} as {};", - myitem.visibility.print_with_space(cx.tcx(), myitem.def_id), - anchor(myitem.def_id, &*src.as_str()), + myitem.visibility.print_with_space(cx.tcx(), myitem.def_id, cx.cache()), + anchor(myitem.def_id, &*src.as_str(), cx.cache()), name ), None => write!( w, "{}extern crate {};", - myitem.visibility.print_with_space(cx.tcx(), myitem.def_id), - anchor(myitem.def_id, &*name.as_str()) + myitem.visibility.print_with_space(cx.tcx(), myitem.def_id, cx.cache()), + anchor(myitem.def_id, &*name.as_str(), cx.cache()) ), } write!(w, ""); @@ -2179,8 +2178,8 @@ fn item_module(w: &mut Buffer, cx: &Context<'_>, item: &clean::Item, items: &[cl write!( w, "{}{}", - myitem.visibility.print_with_space(cx.tcx(), myitem.def_id), - import.print() + myitem.visibility.print_with_space(cx.tcx(), myitem.def_id, cx.cache()), + import.print(cx.cache()) ); } @@ -2211,7 +2210,7 @@ fn item_module(w: &mut Buffer, cx: &Context<'_>, item: &clean::Item, items: &[cl ", name = *myitem.name.as_ref().unwrap(), stab_tags = extra_info_tags(myitem, item, cx.tcx()), - docs = MarkdownSummaryLine(&doc_value, &myitem.links()).into_string(), + docs = MarkdownSummaryLine(&doc_value, &myitem.links(&cx.cache)).into_string(), class = myitem.type_(), add = add, stab = stab.unwrap_or_else(String::new), @@ -2396,9 +2395,9 @@ fn item_constant(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, c: &clean:: write!( w, "{vis}const {name}: {typ}", - vis = it.visibility.print_with_space(cx.tcx(), it.def_id), + vis = it.visibility.print_with_space(cx.tcx(), it.def_id, cx.cache()), name = it.name.as_ref().unwrap(), - typ = c.type_.print(), + typ = c.type_.print(cx.cache()), ); if c.value.is_some() || c.is_literal { @@ -2430,10 +2429,10 @@ fn item_static(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, s: &clean::St write!( w, "{vis}static {mutability}{name}: {typ}", - vis = it.visibility.print_with_space(cx.tcx(), it.def_id), + vis = it.visibility.print_with_space(cx.tcx(), it.def_id, cx.cache()), mutability = s.mutability.print_with_space(), name = it.name.as_ref().unwrap(), - typ = s.type_.print() + typ = s.type_.print(cx.cache()) ); document(w, cx, it, None) } @@ -2441,13 +2440,13 @@ fn item_static(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, s: &clean::St fn item_function(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, f: &clean::Function) { let header_len = format!( "{}{}{}{}{:#}fn {}{:#}", - it.visibility.print_with_space(cx.tcx(), it.def_id), + it.visibility.print_with_space(cx.tcx(), it.def_id, cx.cache()), f.header.constness.print_with_space(), f.header.asyncness.print_with_space(), f.header.unsafety.print_with_space(), print_abi_with_space(f.header.abi), it.name.as_ref().unwrap(), - f.generics.print() + f.generics.print(cx.cache()) ) .len(); write!(w, "
");
@@ -2456,17 +2455,18 @@ fn item_function(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, f: &clean::
         w,
         "{vis}{constness}{asyncness}{unsafety}{abi}fn \
          {name}{generics}{decl}{spotlight}{where_clause}
", - vis = it.visibility.print_with_space(cx.tcx(), it.def_id), + vis = it.visibility.print_with_space(cx.tcx(), it.def_id, cx.cache()), constness = f.header.constness.print_with_space(), asyncness = f.header.asyncness.print_with_space(), unsafety = f.header.unsafety.print_with_space(), abi = print_abi_with_space(f.header.abi), name = it.name.as_ref().unwrap(), - generics = f.generics.print(), - where_clause = WhereClause { gens: &f.generics, indent: 0, end_newline: true }, + generics = f.generics.print(cx.cache()), + where_clause = + WhereClause { gens: &f.generics, indent: 0, end_newline: true }.print(cx.cache()), decl = Function { decl: &f.decl, header_len, indent: 0, asyncness: f.header.asyncness } - .print(), - spotlight = spotlight_decl(&f.decl), + .print(cx.cache()), + spotlight = spotlight_decl(&f.decl, cx.cache()), ); document(w, cx, it, None) } @@ -2478,7 +2478,6 @@ fn render_implementor( w: &mut Buffer, implementor_dups: &FxHashMap, aliases: &[String], - cache: &Cache, ) { // If there's already another implementor that has the same abbridged name, use the // full path, for example in `std::iter::ExactSizeIterator` @@ -2504,7 +2503,6 @@ fn render_implementor( false, false, aliases, - cache, ); } @@ -2513,12 +2511,11 @@ fn render_impls( w: &mut Buffer, traits: &[&&Impl], containing_item: &clean::Item, - cache: &Cache, ) { let mut impls = traits .iter() .map(|i| { - let did = i.trait_did().unwrap(); + let did = i.trait_did_full(cx.cache()).unwrap(); let assoc_link = AssocItemLink::GotoSource(did, &i.inner_impl().provided_trait_methods); let mut buffer = if w.is_for_html() { Buffer::html() } else { Buffer::new() }; render_impl( @@ -2535,7 +2532,6 @@ fn render_impls( false, true, &[], - cache, ); buffer.into_inner() }) @@ -2544,7 +2540,7 @@ fn render_impls( w.write_str(&impls.join("")); } -fn bounds(t_bounds: &[clean::GenericBound], trait_alias: bool) -> String { +fn bounds(t_bounds: &[clean::GenericBound], trait_alias: bool, cache: &Cache) -> String { let mut bounds = String::new(); if !t_bounds.is_empty() { if !trait_alias { @@ -2554,22 +2550,22 @@ fn bounds(t_bounds: &[clean::GenericBound], trait_alias: bool) -> String { if i > 0 { bounds.push_str(" + "); } - bounds.push_str(&p.print().to_string()); + bounds.push_str(&p.print(cache).to_string()); } } bounds } -fn compare_impl<'a, 'b>(lhs: &'a &&Impl, rhs: &'b &&Impl) -> Ordering { - let lhs = format!("{}", lhs.inner_impl().print()); - let rhs = format!("{}", rhs.inner_impl().print()); +fn compare_impl<'a, 'b>(lhs: &'a &&Impl, rhs: &'b &&Impl, cache: &Cache) -> Ordering { + let lhs = format!("{}", lhs.inner_impl().print(cache)); + let rhs = format!("{}", rhs.inner_impl().print(cache)); // lhs and rhs are formatted as HTML, which may be unnecessary compare_names(&lhs, &rhs) } -fn item_trait(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, t: &clean::Trait, cache: &Cache) { - let bounds = bounds(&t.bounds, false); +fn item_trait(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, t: &clean::Trait) { + let bounds = bounds(&t.bounds, false, cx.cache()); let types = t.items.iter().filter(|m| m.is_associated_type()).collect::>(); let consts = t.items.iter().filter(|m| m.is_associated_const()).collect::>(); let required = t.items.iter().filter(|m| m.is_ty_method()).collect::>(); @@ -2582,16 +2578,17 @@ fn item_trait(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, t: &clean::Tra write!( w, "{}{}{}trait {}{}{}", - it.visibility.print_with_space(cx.tcx(), it.def_id), + it.visibility.print_with_space(cx.tcx(), it.def_id, cx.cache()), t.unsafety.print_with_space(), if t.is_auto { "auto " } else { "" }, it.name.as_ref().unwrap(), - t.generics.print(), + t.generics.print(cx.cache()), bounds ); if !t.generics.where_predicates.is_empty() { - write!(w, "{}", WhereClause { gens: &t.generics, indent: 0, end_newline: true }); + let where_ = WhereClause { gens: &t.generics, indent: 0, end_newline: true }; + write!(w, "{}", where_.print(cx.cache())); } else { write!(w, " "); } @@ -2664,13 +2661,7 @@ fn item_trait(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, t: &clean::Tra write!(w, "{}Loading content...", extra_content) } - fn trait_item( - w: &mut Buffer, - cx: &Context<'_>, - m: &clean::Item, - t: &clean::Item, - cache: &Cache, - ) { + fn trait_item(w: &mut Buffer, cx: &Context<'_>, m: &clean::Item, t: &clean::Item) { let name = m.name.as_ref().unwrap(); info!("Documenting {} on {:?}", name, t.name); let item_type = m.type_(); @@ -2679,7 +2670,7 @@ fn item_trait(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, t: &clean::Tra render_assoc_item(w, m, AssocItemLink::Anchor(Some(&id)), ItemType::Impl, cx); write!(w, ""); render_stability_since(w, m, t, cx.tcx()); - write_srclink(cx, m, w, cache); + write_srclink(cx, m, w); write!(w, "

"); document(w, cx, m, Some(t)); } @@ -2692,7 +2683,7 @@ fn item_trait(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, t: &clean::Tra "
", ); for t in types { - trait_item(w, cx, t, it, cache); + trait_item(w, cx, t, it); } write_loading_content(w, "
"); } @@ -2705,7 +2696,7 @@ fn item_trait(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, t: &clean::Tra "
", ); for t in consts { - trait_item(w, cx, t, it, cache); + trait_item(w, cx, t, it); } write_loading_content(w, "
"); } @@ -2719,7 +2710,7 @@ fn item_trait(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, t: &clean::Tra "
", ); for m in required { - trait_item(w, cx, m, it, cache); + trait_item(w, cx, m, it); } write_loading_content(w, "
"); } @@ -2731,15 +2722,15 @@ fn item_trait(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, t: &clean::Tra "
", ); for m in provided { - trait_item(w, cx, m, it, cache); + trait_item(w, cx, m, it); } write_loading_content(w, "
"); } // If there are methods directly on this trait object, render them here. - render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All, cache); + render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All); - if let Some(implementors) = cache.implementors.get(&it.def_id) { + if let Some(implementors) = cx.cache.implementors.get(&it.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 = FxHashMap::default(); @@ -2761,14 +2752,17 @@ fn item_trait(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, t: &clean::Tra } let (local, foreign) = implementors.iter().partition::, _>(|i| { - i.inner_impl().for_.def_id().map_or(true, |d| cache.paths.contains_key(&d)) + i.inner_impl() + .for_ + .def_id_full(cx.cache()) + .map_or(true, |d| cx.cache.paths.contains_key(&d)) }); let (mut synthetic, mut concrete): (Vec<&&Impl>, Vec<&&Impl>) = local.iter().partition(|i| i.inner_impl().synthetic); - synthetic.sort_by(compare_impl); - concrete.sort_by(compare_impl); + synthetic.sort_by(|a, b| compare_impl(a, b, cx.cache())); + concrete.sort_by(|a, b| compare_impl(a, b, cx.cache())); if !foreign.is_empty() { write_small_section_header(w, "foreign-impls", "Implementations on Foreign Types", ""); @@ -2792,7 +2786,6 @@ fn item_trait(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, t: &clean::Tra true, false, &[], - cache, ); } write_loading_content(w, ""); @@ -2805,7 +2798,7 @@ fn item_trait(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, t: &clean::Tra "
", ); for implementor in concrete { - render_implementor(cx, implementor, it, w, &implementor_dups, &[], cache); + render_implementor(cx, implementor, it, w, &implementor_dups, &[]); } write_loading_content(w, "
"); @@ -2823,8 +2816,7 @@ fn item_trait(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, t: &clean::Tra it, w, &implementor_dups, - &collect_paths_for_type(implementor.inner_impl().for_.clone()), - cache, + &collect_paths_for_type(implementor.inner_impl().for_.clone(), &cx.cache), ); } write_loading_content(w, ""); @@ -2860,7 +2852,7 @@ fn item_trait(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, t: &clean::Tra path = if it.def_id.is_local() { cx.current.join("/") } else { - let (ref path, _) = cache.external_paths[&it.def_id]; + let (ref path, _) = cx.cache.external_paths[&it.def_id]; path[..path.len() - 1].join("/") }, ty = it.type_(), @@ -2868,7 +2860,7 @@ fn item_trait(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, t: &clean::Tra ); } -fn naive_assoc_href(it: &clean::Item, link: AssocItemLink<'_>) -> String { +fn naive_assoc_href(it: &clean::Item, link: AssocItemLink<'_>, cache: &Cache) -> String { use crate::formats::item_type::ItemType::*; let name = it.name.as_ref().unwrap(); @@ -2882,7 +2874,7 @@ fn naive_assoc_href(it: &clean::Item, link: AssocItemLink<'_>) -> String { AssocItemLink::Anchor(Some(ref id)) => format!("#{}", id), AssocItemLink::Anchor(None) => anchor, AssocItemLink::GotoSource(did, _) => { - href(did).map(|p| format!("{}{}", p.0, anchor)).unwrap_or(anchor) + href(did, cache).map(|p| format!("{}{}", p.0, anchor)).unwrap_or(anchor) } } } @@ -2900,10 +2892,10 @@ fn assoc_const( w, "{}{}const {}: {}", extra, - it.visibility.print_with_space(cx.tcx(), it.def_id), - naive_assoc_href(it, link), + it.visibility.print_with_space(cx.tcx(), it.def_id, cx.cache()), + naive_assoc_href(it, link, cx.cache()), it.name.as_ref().unwrap(), - ty.print() + ty.print(cx.cache()) ); } @@ -2914,19 +2906,20 @@ fn assoc_type( default: Option<&clean::Type>, link: AssocItemLink<'_>, extra: &str, + cache: &Cache, ) { write!( w, "{}type {}", extra, - naive_assoc_href(it, link), + naive_assoc_href(it, link, cache), it.name.as_ref().unwrap() ); if !bounds.is_empty() { - write!(w, ": {}", print_generic_bounds(bounds)) + write!(w, ": {}", print_generic_bounds(bounds, cache)) } if let Some(default) = default { - write!(w, " = {}", default.print()) + write!(w, " = {}", default.print(cache)) } } @@ -3005,19 +2998,19 @@ fn render_assoc_item( ItemType::TyMethod }; - href(did).map(|p| format!("{}#{}.{}", p.0, ty, name)).unwrap_or(anchor) + href(did, cx.cache()).map(|p| format!("{}#{}.{}", p.0, ty, name)).unwrap_or(anchor) } }; let mut header_len = format!( "{}{}{}{}{}{:#}fn {}{:#}", - meth.visibility.print_with_space(cx.tcx(), meth.def_id), + meth.visibility.print_with_space(cx.tcx(), meth.def_id, cx.cache()), header.constness.print_with_space(), header.asyncness.print_with_space(), header.unsafety.print_with_space(), print_default_space(meth.is_default()), print_abi_with_space(header.abi), name, - g.print() + g.print(cx.cache()) ) .len(); let (indent, end_newline) = if parent == ItemType::Trait { @@ -3032,7 +3025,7 @@ fn render_assoc_item( "{}{}{}{}{}{}{}fn {name}\ {generics}{decl}{spotlight}{where_clause}", if parent == ItemType::Trait { " " } else { "" }, - meth.visibility.print_with_space(cx.tcx(), meth.def_id), + meth.visibility.print_with_space(cx.tcx(), meth.def_id, cx.cache()), header.constness.print_with_space(), header.asyncness.print_with_space(), header.unsafety.print_with_space(), @@ -3040,10 +3033,11 @@ fn render_assoc_item( print_abi_with_space(header.abi), href = href, name = name, - generics = g.print(), - decl = Function { decl: d, header_len, indent, asyncness: header.asyncness }.print(), - spotlight = spotlight_decl(&d), - where_clause = WhereClause { gens: g, indent, end_newline } + generics = g.print(cx.cache()), + decl = Function { decl: d, header_len, indent, asyncness: header.asyncness } + .print(cx.cache()), + spotlight = spotlight_decl(&d, cx.cache()), + where_clause = WhereClause { gens: g, indent, end_newline }.print(cx.cache()) ) } match *item.kind { @@ -3070,18 +3064,13 @@ fn render_assoc_item( default.as_ref(), link, if parent == ItemType::Trait { " " } else { "" }, + cx.cache(), ), _ => panic!("render_assoc_item called on non-associated-item"), } } -fn item_struct( - w: &mut Buffer, - cx: &Context<'_>, - it: &clean::Item, - s: &clean::Struct, - cache: &Cache, -) { +fn item_struct(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, s: &clean::Struct) { wrap_into_docblock(w, |w| { write!(w, "
");
         render_attributes(w, it, true);
@@ -3122,16 +3111,16 @@ fn item_struct(
                     item_type = ItemType::StructField,
                     id = id,
                     name = field.name.as_ref().unwrap(),
-                    ty = ty.print()
+                    ty = ty.print(cx.cache())
                 );
                 document(w, cx, field, Some(it));
             }
         }
     }
-    render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All, cache)
+    render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All)
 }
 
-fn item_union(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, s: &clean::Union, cache: &Cache) {
+fn item_union(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, s: &clean::Union) {
     wrap_into_docblock(w, |w| {
         write!(w, "
");
         render_attributes(w, it, true);
@@ -3166,7 +3155,7 @@ fn item_union(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, s: &clean::Uni
                 id = id,
                 name = name,
                 shortty = ItemType::StructField,
-                ty = ty.print()
+                ty = ty.print(cx.cache())
             );
             if let Some(stability_class) = field.stability_class(cx.tcx()) {
                 write!(w, "", stab = stability_class);
@@ -3174,20 +3163,20 @@ fn item_union(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, s: &clean::Uni
             document(w, cx, field, Some(it));
         }
     }
-    render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All, cache)
+    render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All)
 }
 
-fn item_enum(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, e: &clean::Enum, cache: &Cache) {
+fn item_enum(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, e: &clean::Enum) {
     wrap_into_docblock(w, |w| {
         write!(w, "
");
         render_attributes(w, it, true);
         write!(
             w,
             "{}enum {}{}{}",
-            it.visibility.print_with_space(cx.tcx(), it.def_id),
+            it.visibility.print_with_space(cx.tcx(), it.def_id, cx.cache()),
             it.name.as_ref().unwrap(),
-            e.generics.print(),
-            WhereClause { gens: &e.generics, indent: 0, end_newline: true }
+            e.generics.print(cx.cache()),
+            WhereClause { gens: &e.generics, indent: 0, end_newline: true }.print(cx.cache())
         );
         if e.variants.is_empty() && !e.variants_stripped {
             write!(w, " {{}}");
@@ -3205,7 +3194,7 @@ fn item_enum(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, e: &clean::Enum
                                 if i > 0 {
                                     write!(w, ", ")
                                 }
-                                write!(w, "{}", ty.print());
+                                write!(w, "{}", ty.print(cx.cache()));
                             }
                             write!(w, ")");
                         }
@@ -3252,7 +3241,7 @@ fn item_enum(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, e: &clean::Enum
                     if i > 0 {
                         write!(w, ", ");
                     }
-                    write!(w, "{}", ty.print());
+                    write!(w, "{}", ty.print(cx.cache()));
                 }
                 write!(w, ")");
             }
@@ -3289,7 +3278,7 @@ fn item_enum(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, e: &clean::Enum
                              ",
                             id = id,
                             f = field.name.as_ref().unwrap(),
-                            t = ty.print()
+                            t = ty.print(cx.cache())
                         );
                         document(w, cx, field, Some(variant));
                     }
@@ -3299,7 +3288,7 @@ fn item_enum(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, e: &clean::Enum
             render_stability_since(w, variant, it, cx.tcx());
         }
     }
-    render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All, cache)
+    render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All)
 }
 
 const ALLOWED_ATTRIBUTES: &[Symbol] = &[
@@ -3357,17 +3346,21 @@ fn render_struct(
     write!(
         w,
         "{}{}{}",
-        it.visibility.print_with_space(cx.tcx(), it.def_id),
+        it.visibility.print_with_space(cx.tcx(), it.def_id, cx.cache()),
         if structhead { "struct " } else { "" },
         it.name.as_ref().unwrap()
     );
     if let Some(g) = g {
-        write!(w, "{}", g.print())
+        write!(w, "{}", g.print(cx.cache()))
     }
     match ty {
         CtorKind::Fictive => {
             if let Some(g) = g {
-                write!(w, "{}", WhereClause { gens: g, indent: 0, end_newline: true })
+                write!(
+                    w,
+                    "{}",
+                    WhereClause { gens: g, indent: 0, end_newline: true }.print(cx.cache())
+                )
             }
             let mut has_visible_fields = false;
             write!(w, " {{");
@@ -3377,9 +3370,9 @@ fn render_struct(
                         w,
                         "\n{}    {}{}: {},",
                         tab,
-                        field.visibility.print_with_space(cx.tcx(), field.def_id),
+                        field.visibility.print_with_space(cx.tcx(), field.def_id, cx.cache()),
                         field.name.as_ref().unwrap(),
-                        ty.print()
+                        ty.print(cx.cache())
                     );
                     has_visible_fields = true;
                 }
@@ -3409,8 +3402,8 @@ fn render_struct(
                         write!(
                             w,
                             "{}{}",
-                            field.visibility.print_with_space(cx.tcx(), field.def_id),
-                            ty.print()
+                            field.visibility.print_with_space(cx.tcx(), field.def_id, cx.cache()),
+                            ty.print(cx.cache())
                         )
                     }
                     _ => unreachable!(),
@@ -3418,14 +3411,22 @@ fn render_struct(
             }
             write!(w, ")");
             if let Some(g) = g {
-                write!(w, "{}", WhereClause { gens: g, indent: 0, end_newline: false })
+                write!(
+                    w,
+                    "{}",
+                    WhereClause { gens: g, indent: 0, end_newline: false }.print(cx.cache())
+                )
             }
             write!(w, ";");
         }
         CtorKind::Const => {
             // Needed for PhantomData.
             if let Some(g) = g {
-                write!(w, "{}", WhereClause { gens: g, indent: 0, end_newline: false })
+                write!(
+                    w,
+                    "{}",
+                    WhereClause { gens: g, indent: 0, end_newline: false }.print(cx.cache())
+                )
             }
             write!(w, ";");
         }
@@ -3444,13 +3445,13 @@ fn render_union(
     write!(
         w,
         "{}{}{}",
-        it.visibility.print_with_space(cx.tcx(), it.def_id),
+        it.visibility.print_with_space(cx.tcx(), it.def_id, cx.cache()),
         if structhead { "union " } else { "" },
         it.name.as_ref().unwrap()
     );
     if let Some(g) = g {
-        write!(w, "{}", g.print());
-        write!(w, "{}", WhereClause { gens: g, indent: 0, end_newline: true });
+        write!(w, "{}", g.print(cx.cache()));
+        write!(w, "{}", WhereClause { gens: g, indent: 0, end_newline: true }.print(cx.cache()));
     }
 
     write!(w, " {{\n{}", tab);
@@ -3459,9 +3460,9 @@ fn render_union(
             write!(
                 w,
                 "    {}{}: {},\n{}",
-                field.visibility.print_with_space(cx.tcx(), field.def_id),
+                field.visibility.print_with_space(cx.tcx(), field.def_id, cx.cache()),
                 field.name.as_ref().unwrap(),
-                ty.print(),
+                ty.print(cx.cache()),
                 tab
             );
         }
@@ -3494,10 +3495,9 @@ fn render_assoc_items(
     containing_item: &clean::Item,
     it: DefId,
     what: AssocItemRender<'_>,
-    cache: &Cache,
 ) {
     info!("Documenting associated items of {:?}", containing_item.name);
-    let v = match cache.impls.get(&it) {
+    let v = match cx.cache.impls.get(&it) {
         Some(v) => v,
         None => return,
     };
@@ -3514,9 +3514,13 @@ fn render_assoc_items(
                 RenderMode::Normal
             }
             AssocItemRender::DerefFor { trait_, type_, deref_mut_ } => {
-                let id =
-                    cx.derive_id(small_url_encode(&format!("deref-methods-{:#}", type_.print())));
-                cx.deref_id_map.borrow_mut().insert(type_.def_id().unwrap(), id.clone());
+                let id = cx.derive_id(small_url_encode(&format!(
+                    "deref-methods-{:#}",
+                    type_.print(cx.cache())
+                )));
+                cx.deref_id_map
+                    .borrow_mut()
+                    .insert(type_.def_id_full(cx.cache()).unwrap(), id.clone());
                 write!(
                     w,
                     "
\
@@ -3524,8 +3528,8 @@ fn render_assoc_items(
                          \
                      
",
                     id = id,
-                    trait_ = trait_.print(),
-                    type_ = type_.print(),
+                    trait_ = trait_.print(cx.cache()),
+                    type_ = type_.print(cx.cache()),
                 );
                 RenderMode::ForDeref { mut_: deref_mut_ }
             }
@@ -3545,17 +3549,18 @@ fn render_assoc_items(
                 false,
                 true,
                 &[],
-                cache,
             );
         }
     }
     if !traits.is_empty() {
-        let deref_impl =
-            traits.iter().find(|t| t.inner_impl().trait_.def_id() == cache.deref_trait_did);
+        let deref_impl = traits
+            .iter()
+            .find(|t| t.inner_impl().trait_.def_id_full(cx.cache()) == cx.cache.deref_trait_did);
         if let Some(impl_) = deref_impl {
-            let has_deref_mut =
-                traits.iter().any(|t| t.inner_impl().trait_.def_id() == cache.deref_mut_trait_did);
-            render_deref_methods(w, cx, impl_, containing_item, has_deref_mut, cache);
+            let has_deref_mut = traits.iter().any(|t| {
+                t.inner_impl().trait_.def_id_full(cx.cache()) == cx.cache.deref_mut_trait_did
+            });
+            render_deref_methods(w, cx, impl_, containing_item, has_deref_mut);
         }
 
         // If we were already one level into rendering deref methods, we don't want to render
@@ -3570,7 +3575,7 @@ fn render_assoc_items(
             concrete.into_iter().partition(|t| t.inner_impl().blanket_impl.is_some());
 
         let mut impls = Buffer::empty_from(&w);
-        render_impls(cx, &mut impls, &concrete, containing_item, cache);
+        render_impls(cx, &mut impls, &concrete, containing_item);
         let impls = impls.into_inner();
         if !impls.is_empty() {
             write!(
@@ -3592,7 +3597,7 @@ fn render_assoc_items(
                  \
                  
"
             );
-            render_impls(cx, w, &synthetic, containing_item, cache);
+            render_impls(cx, w, &synthetic, containing_item);
             write!(w, "
");
         }
 
@@ -3605,7 +3610,7 @@ fn render_assoc_items(
                  \
                  
"
             );
-            render_impls(cx, w, &blanket_impl, containing_item, cache);
+            render_impls(cx, w, &blanket_impl, containing_item);
             write!(w, "
");
         }
     }
@@ -3617,7 +3622,6 @@ fn render_deref_methods(
     impl_: &Impl,
     container_item: &clean::Item,
     deref_mut: bool,
-    cache: &Cache,
 ) {
     let deref_type = impl_.inner_impl().trait_.as_ref().unwrap();
     let (target, real_target) = impl_
@@ -3634,25 +3638,25 @@ fn render_deref_methods(
         .expect("Expected associated type binding");
     let what =
         AssocItemRender::DerefFor { trait_: deref_type, type_: real_target, deref_mut_: deref_mut };
-    if let Some(did) = target.def_id() {
-        if let Some(type_did) = impl_.inner_impl().for_.def_id() {
+    if let Some(did) = target.def_id_full(cx.cache()) {
+        if let Some(type_did) = impl_.inner_impl().for_.def_id_full(cx.cache()) {
             // `impl Deref for S`
             if did == type_did {
                 // Avoid infinite cycles
                 return;
             }
         }
-        render_assoc_items(w, cx, container_item, did, what, cache);
+        render_assoc_items(w, cx, container_item, did, what);
     } else {
         if let Some(prim) = target.primitive_type() {
-            if let Some(&did) = cache.primitive_locations.get(&prim) {
-                render_assoc_items(w, cx, container_item, did, what, cache);
+            if let Some(&did) = cx.cache.primitive_locations.get(&prim) {
+                render_assoc_items(w, cx, container_item, did, what);
             }
         }
     }
 }
 
-fn should_render_item(item: &clean::Item, deref_mut_: bool) -> bool {
+fn should_render_item(item: &clean::Item, deref_mut_: bool, cache: &Cache) -> bool {
     let self_type_opt = match *item.kind {
         clean::MethodItem(ref method, _) => method.decl.self_type(),
         clean::TyMethodItem(ref method) => method.decl.self_type(),
@@ -3666,7 +3670,7 @@ fn should_render_item(item: &clean::Item, deref_mut_: bool) -> bool {
                 (mutability == Mutability::Mut, false, false)
             }
             SelfTy::SelfExplicit(clean::ResolvedPath { did, .. }) => {
-                (false, Some(did) == cache().owned_box_did, false)
+                (false, Some(did) == cache.owned_box_did, false)
             }
             SelfTy::SelfValue => (false, false, true),
             _ => (false, false, false),
@@ -3678,31 +3682,31 @@ fn should_render_item(item: &clean::Item, deref_mut_: bool) -> bool {
     }
 }
 
-fn spotlight_decl(decl: &clean::FnDecl) -> String {
+fn spotlight_decl(decl: &clean::FnDecl, cache: &Cache) -> String {
     let mut out = Buffer::html();
     let mut trait_ = String::new();
 
-    if let Some(did) = decl.output.def_id() {
-        let c = cache();
-        if let Some(impls) = c.impls.get(&did) {
+    if let Some(did) = decl.output.def_id_full(cache) {
+        if let Some(impls) = cache.impls.get(&did) {
             for i in impls {
                 let impl_ = i.inner_impl();
-                if impl_.trait_.def_id().map_or(false, |d| c.traits[&d].is_spotlight) {
+                if impl_.trait_.def_id_full(cache).map_or(false, |d| cache.traits[&d].is_spotlight)
+                {
                     if out.is_empty() {
                         out.push_str(&format!(
                             "
Notable traits for {}
\
                              ",
-                            impl_.for_.print()
+                            impl_.for_.print(cache)
                         ));
-                        trait_.push_str(&impl_.for_.print().to_string());
+                        trait_.push_str(&impl_.for_.print(cache).to_string());
                     }
 
                     //use the "where" class here to make it small
                     out.push_str(&format!(
                         "{}",
-                        impl_.print()
+                        impl_.print(cache)
                     ));
-                    let t_did = impl_.trait_.def_id().unwrap();
+                    let t_did = impl_.trait_.def_id_full(cache).unwrap();
                     for it in &impl_.items {
                         if let clean::TypedefItem(ref tydef, _) = *it.kind {
                             out.push_str("    ");
@@ -3713,6 +3717,7 @@ fn spotlight_decl(decl: &clean::FnDecl) -> String {
                                 Some(&tydef.type_),
                                 AssocItemLink::GotoSource(t_did, &FxHashSet::default()),
                                 "",
+                                cache,
                             );
                             out.push_str(";");
                         }
@@ -3750,18 +3755,17 @@ fn render_impl(
     // 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],
-    cache: &Cache,
 ) {
-    let traits = &cache.traits;
-    let trait_ = i.trait_did().map(|did| &traits[&did]);
+    let traits = &cx.cache.traits;
+    let trait_ = i.trait_did_full(cx.cache()).map(|did| &traits[&did]);
 
     if render_mode == RenderMode::Normal {
         let id = cx.derive_id(match i.inner_impl().trait_ {
             Some(ref t) => {
                 if is_on_foreign_type {
-                    get_id_for_impl_on_foreign_type(&i.inner_impl().for_, t)
+                    get_id_for_impl_on_foreign_type(&i.inner_impl().for_, t, cx.cache())
                 } else {
-                    format!("impl-{}", small_url_encode(&format!("{:#}", t.print())))
+                    format!("impl-{}", small_url_encode(&format!("{:#}", t.print(cx.cache()))))
                 }
             }
             None => "impl".to_string(),
@@ -3773,12 +3777,20 @@ fn render_impl(
         };
         if let Some(use_absolute) = use_absolute {
             write!(w, "
", id, aliases);
-            fmt_impl_for_trait_page(&i.inner_impl(), w, use_absolute);
+            fmt_impl_for_trait_page(&i.inner_impl(), w, use_absolute, cx.cache());
             if show_def_docs {
                 for it in &i.inner_impl().items {
                     if let clean::TypedefItem(ref tydef, _) = *it.kind {
                         write!(w, "  ");
-                        assoc_type(w, it, &[], Some(&tydef.type_), AssocItemLink::Anchor(None), "");
+                        assoc_type(
+                            w,
+                            it,
+                            &[],
+                            Some(&tydef.type_),
+                            AssocItemLink::Anchor(None),
+                            "",
+                            cx.cache(),
+                        );
                         write!(w, ";");
                     }
                 }
@@ -3790,7 +3802,7 @@ fn render_impl(
                 "
{}",
                 id,
                 aliases,
-                i.inner_impl().print()
+                i.inner_impl().print(cx.cache())
             );
         }
         write!(w, "", id);
@@ -3801,7 +3813,7 @@ fn render_impl(
             outer_version,
             outer_const_version,
         );
-        write_srclink(cx, &i.impl_item, w, cache);
+        write_srclink(cx, &i.impl_item, w);
         write!(w, "
");
 
         if trait_.is_some() {
@@ -3817,7 +3829,7 @@ fn render_impl(
                 "
{}
",
                 Markdown(
                     &*dox,
-                    &i.impl_item.links(),
+                    &i.impl_item.links(&cx.cache),
                     &mut ids,
                     cx.shared.codes,
                     cx.shared.edition,
@@ -3840,14 +3852,15 @@ fn render_impl(
         outer_const_version: Option<&str>,
         trait_: Option<&clean::Trait>,
         show_def_docs: bool,
-        cache: &Cache,
     ) {
         let item_type = item.type_();
         let name = item.name.as_ref().unwrap();
 
         let render_method_item = match render_mode {
             RenderMode::Normal => true,
-            RenderMode::ForDeref { mut_: deref_mut_ } => should_render_item(&item, deref_mut_),
+            RenderMode::ForDeref { mut_: deref_mut_ } => {
+                should_render_item(&item, deref_mut_, &cx.cache)
+            }
         };
 
         let (is_hidden, extra_class) =
@@ -3874,14 +3887,22 @@ fn render_impl(
                         outer_version,
                         outer_const_version,
                     );
-                    write_srclink(cx, item, w, cache);
+                    write_srclink(cx, item, w);
                     write!(w, "
");
                 }
             }
             clean::TypedefItem(ref tydef, _) => {
                 let id = cx.derive_id(format!("{}.{}", ItemType::AssocType, name));
                 write!(w, "
", id, item_type, extra_class);
-                assoc_type(w, item, &Vec::new(), Some(&tydef.type_), link.anchor(&id), "");
+                assoc_type(
+                    w,
+                    item,
+                    &Vec::new(),
+                    Some(&tydef.type_),
+                    link.anchor(&id),
+                    "",
+                    cx.cache(),
+                );
                 write!(w, "
");
             }
             clean::AssocConstItem(ref ty, ref default) => {
@@ -3896,13 +3917,13 @@ fn render_impl(
                     outer_version,
                     outer_const_version,
                 );
-                write_srclink(cx, item, w, cache);
+                write_srclink(cx, item, w);
                 write!(w, "");
             }
             clean::AssocTypeItem(ref bounds, ref default) => {
                 let id = cx.derive_id(format!("{}.{}", item_type, name));
                 write!(w, "
", id, item_type, extra_class);
-                assoc_type(w, item, bounds, default.as_ref(), link.anchor(&id), "");
+                assoc_type(w, item, bounds, default.as_ref(), link.anchor(&id), "", cx.cache());
                 write!(w, "
");
             }
             clean::StrippedItem(..) => return,
@@ -3961,7 +3982,6 @@ fn render_impl(
             outer_const_version,
             trait_,
             show_def_docs,
-            cache,
         );
     }
 
@@ -3975,14 +3995,13 @@ fn render_impl(
         outer_version: Option<&str>,
         outer_const_version: Option<&str>,
         show_def_docs: bool,
-        cache: &Cache,
     ) {
         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().unwrap();
+            let did = i.trait_.as_ref().unwrap().def_id_full(cx.cache()).unwrap();
             let assoc_link = AssocItemLink::GotoSource(did, &i.provided_trait_methods);
 
             doc_impl_item(
@@ -3997,7 +4016,6 @@ fn render_impl(
                 outer_const_version,
                 None,
                 show_def_docs,
-                cache,
             );
         }
     }
@@ -4018,29 +4036,23 @@ fn render_impl(
                 outer_version,
                 outer_const_version,
                 show_def_docs,
-                cache,
             );
         }
     }
     write!(w, "");
 }
 
-fn item_opaque_ty(
-    w: &mut Buffer,
-    cx: &Context<'_>,
-    it: &clean::Item,
-    t: &clean::OpaqueTy,
-    cache: &Cache,
-) {
+fn item_opaque_ty(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, t: &clean::OpaqueTy) {
     write!(w, "
");
     render_attributes(w, it, false);
     write!(
         w,
         "type {}{}{where_clause} = impl {bounds};
",
         it.name.as_ref().unwrap(),
-        t.generics.print(),
-        where_clause = WhereClause { gens: &t.generics, indent: 0, end_newline: true },
-        bounds = bounds(&t.bounds, false)
+        t.generics.print(cx.cache()),
+        where_clause =
+            WhereClause { gens: &t.generics, indent: 0, end_newline: true }.print(cx.cache()),
+        bounds = bounds(&t.bounds, false, cx.cache())
     );
 
     document(w, cx, it, None);
@@ -4049,25 +4061,19 @@ fn item_opaque_ty(
     // 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.def_id, AssocItemRender::All, cache)
+    render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All)
 }
 
-fn item_trait_alias(
-    w: &mut Buffer,
-    cx: &Context<'_>,
-    it: &clean::Item,
-    t: &clean::TraitAlias,
-    cache: &Cache,
-) {
+fn item_trait_alias(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, t: &clean::TraitAlias) {
     write!(w, "
");
     render_attributes(w, it, false);
     write!(
         w,
         "trait {}{}{} = {};
",
         it.name.as_ref().unwrap(),
-        t.generics.print(),
-        WhereClause { gens: &t.generics, indent: 0, end_newline: true },
-        bounds(&t.bounds, true)
+        t.generics.print(cx.cache()),
+        WhereClause { gens: &t.generics, indent: 0, end_newline: true }.print(cx.cache()),
+        bounds(&t.bounds, true, cx.cache())
     );
 
     document(w, cx, it, None);
@@ -4076,25 +4082,20 @@ fn item_trait_alias(
     // 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.def_id, AssocItemRender::All, cache)
+    render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All)
 }
 
-fn item_typedef(
-    w: &mut Buffer,
-    cx: &Context<'_>,
-    it: &clean::Item,
-    t: &clean::Typedef,
-    cache: &Cache,
-) {
+fn item_typedef(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, t: &clean::Typedef) {
     write!(w, "
");
     render_attributes(w, it, false);
     write!(
         w,
         "type {}{}{where_clause} = {type_};
",
         it.name.as_ref().unwrap(),
-        t.generics.print(),
-        where_clause = WhereClause { gens: &t.generics, indent: 0, end_newline: true },
-        type_ = t.type_.print()
+        t.generics.print(cx.cache()),
+        where_clause =
+            WhereClause { gens: &t.generics, indent: 0, end_newline: true }.print(cx.cache()),
+        type_ = t.type_.print(cx.cache())
     );
 
     document(w, cx, it, None);
@@ -4103,25 +4104,25 @@ fn item_typedef(
     // 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.def_id, AssocItemRender::All, cache)
+    render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All)
 }
 
-fn item_foreign_type(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, cache: &Cache) {
+fn item_foreign_type(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item) {
     writeln!(w, "
extern {{");
     render_attributes(w, it, false);
     write!(
         w,
         "    {}type {};\n}}
",
-        it.visibility.print_with_space(cx.tcx(), it.def_id),
+        it.visibility.print_with_space(cx.tcx(), it.def_id, cx.cache()),
         it.name.as_ref().unwrap(),
     );
 
     document(w, cx, it, None);
 
-    render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All, cache)
+    render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All)
 }
 
-fn print_sidebar(cx: &Context<'_>, it: &clean::Item, buffer: &mut Buffer, cache: &Cache) {
+fn print_sidebar(cx: &Context<'_>, it: &clean::Item, buffer: &mut Buffer) {
     let parentlen = cx.current.len() - if it.is_mod() { 1 } else { 0 };
 
     if it.is_struct()
@@ -4156,7 +4157,7 @@ fn print_sidebar(cx: &Context<'_>, it: &clean::Item, buffer: &mut Buffer, cache:
     }
 
     if it.is_crate() {
-        if let Some(ref version) = cache.crate_version {
+        if let Some(ref version) = cx.cache.crate_version {
             write!(
                 buffer,
                 "
\
@@ -4245,12 +4246,13 @@ fn get_methods(
     for_deref: bool,
     used_links: &mut FxHashSet,
     deref_mut: bool,
+    cache: &Cache,
 ) -> Vec {
     i.items
         .iter()
         .filter_map(|item| match item.name {
             Some(ref name) if !name.is_empty() && item.is_method() => {
-                if !for_deref || should_render_item(item, deref_mut) {
+                if !for_deref || should_render_item(item, deref_mut, cache) {
                     Some(format!(
                         "{}",
                         get_next_url(used_links, format!("method.{}", name)),
@@ -4283,8 +4285,7 @@ fn small_url_encode(s: &str) -> String {
 
 fn sidebar_assoc_items(cx: &Context<'_>, it: &clean::Item) -> String {
     let mut out = String::new();
-    let c = cache();
-    if let Some(v) = c.impls.get(&it.def_id) {
+    if let Some(v) = cx.cache.impls.get(&it.def_id) {
         let mut used_links = FxHashSet::default();
 
         {
@@ -4292,7 +4293,9 @@ fn sidebar_assoc_items(cx: &Context<'_>, it: &clean::Item) -> String {
             let mut ret = v
                 .iter()
                 .filter(|i| i.inner_impl().trait_.is_none())
-                .flat_map(move |i| get_methods(i.inner_impl(), false, used_links_bor, false))
+                .flat_map(move |i| {
+                    get_methods(i.inner_impl(), false, used_links_bor, false, &cx.cache)
+                })
                 .collect::>();
             if !ret.is_empty() {
                 // We want links' order to be reproducible so we don't use unstable sort.
@@ -4309,7 +4312,7 @@ fn sidebar_assoc_items(cx: &Context<'_>, it: &clean::Item) -> String {
             if let Some(impl_) = v
                 .iter()
                 .filter(|i| i.inner_impl().trait_.is_some())
-                .find(|i| i.inner_impl().trait_.def_id() == c.deref_trait_did)
+                .find(|i| i.inner_impl().trait_.def_id_full(cx.cache()) == cx.cache.deref_trait_did)
             {
                 out.push_str(&sidebar_deref_methods(cx, impl_, v));
             }
@@ -4320,9 +4323,9 @@ fn sidebar_assoc_items(cx: &Context<'_>, it: &clean::Item) -> String {
                     .iter()
                     .filter_map(|it| {
                         if let Some(ref i) = it.inner_impl().trait_ {
-                            let i_display = format!("{:#}", i.print());
+                            let i_display = format!("{:#}", i.print(cx.cache()));
                             let out = Escape(&i_display);
-                            let encoded = small_url_encode(&format!("{:#}", i.print()));
+                            let encoded = small_url_encode(&format!("{:#}", i.print(cx.cache())));
                             let generated = format!(
                                 "{}{}",
                                 encoded,
@@ -4380,7 +4383,7 @@ fn sidebar_assoc_items(cx: &Context<'_>, it: &clean::Item) -> String {
 
 fn sidebar_deref_methods(cx: &Context<'_>, impl_: &Impl, v: &Vec) -> String {
     let mut out = String::new();
-    let c = cache();
+    let c = cx.cache();
 
     debug!("found Deref: {:?}", impl_);
     if let Some((target, real_target)) =
@@ -4396,9 +4399,9 @@ fn sidebar_deref_methods(cx: &Context<'_>, impl_: &Impl, v: &Vec) -> Strin
         let deref_mut = v
             .iter()
             .filter(|i| i.inner_impl().trait_.is_some())
-            .any(|i| i.inner_impl().trait_.def_id() == c.deref_mut_trait_did);
+            .any(|i| i.inner_impl().trait_.def_id_full(cx.cache()) == c.deref_mut_trait_did);
         let inner_impl = target
-            .def_id()
+            .def_id_full(cx.cache())
             .or_else(|| {
                 target.primitive_type().and_then(|prim| c.primitive_locations.get(&prim).cloned())
             })
@@ -4409,18 +4412,18 @@ fn sidebar_deref_methods(cx: &Context<'_>, impl_: &Impl, v: &Vec) -> Strin
             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))
+                .flat_map(|i| get_methods(i.inner_impl(), true, &mut used_links, deref_mut, c))
                 .collect::>();
             if !ret.is_empty() {
                 let deref_id_map = cx.deref_id_map.borrow();
                 let id = deref_id_map
-                    .get(&real_target.def_id().unwrap())
+                    .get(&real_target.def_id_full(cx.cache()).unwrap())
                     .expect("Deref section without derived id");
                 out.push_str(&format!(
                     "Methods from {}<Target={}>",
                     id,
-                    Escape(&format!("{:#}", impl_.inner_impl().trait_.as_ref().unwrap().print())),
-                    Escape(&format!("{:#}", real_target.print())),
+                    Escape(&format!("{:#}", impl_.inner_impl().trait_.as_ref().unwrap().print(c))),
+                    Escape(&format!("{:#}", real_target.print(c))),
                 ));
                 // We want links' order to be reproducible so we don't use unstable sort.
                 ret.sort();
@@ -4429,14 +4432,14 @@ fn sidebar_deref_methods(cx: &Context<'_>, impl_: &Impl, v: &Vec) -> Strin
         }
 
         // Recurse into any further impls that might exist for `target`
-        if let Some(target_did) = target.def_id() {
+        if let Some(target_did) = target.def_id_full(cx.cache()) {
             if let Some(target_impls) = c.impls.get(&target_did) {
                 if let Some(target_deref_impl) = target_impls
                     .iter()
                     .filter(|i| i.inner_impl().trait_.is_some())
-                    .find(|i| i.inner_impl().trait_.def_id() == c.deref_trait_did)
+                    .find(|i| i.inner_impl().trait_.def_id_full(cx.cache()) == c.deref_trait_did)
                 {
-                    if let Some(type_did) = impl_.inner_impl().for_.def_id() {
+                    if let Some(type_did) = impl_.inner_impl().for_.def_id_full(cx.cache()) {
                         // `impl Deref for S`
                         if target_did == type_did {
                             // Avoid infinite cycles
@@ -4473,17 +4476,21 @@ fn sidebar_struct(cx: &Context<'_>, buf: &mut Buffer, it: &clean::Item, s: &clea
     }
 }
 
-fn get_id_for_impl_on_foreign_type(for_: &clean::Type, trait_: &clean::Type) -> String {
-    small_url_encode(&format!("impl-{:#}-for-{:#}", trait_.print(), for_.print()))
+fn get_id_for_impl_on_foreign_type(
+    for_: &clean::Type,
+    trait_: &clean::Type,
+    cache: &Cache,
+) -> String {
+    small_url_encode(&format!("impl-{:#}-for-{:#}", trait_.print(cache), for_.print(cache)))
 }
 
-fn extract_for_impl_name(item: &clean::Item) -> Option<(String, String)> {
+fn extract_for_impl_name(item: &clean::Item, cache: &Cache) -> Option<(String, String)> {
     match *item.kind {
         clean::ItemKind::ImplItem(ref i) => {
             if let Some(ref trait_) = i.trait_ {
                 Some((
-                    format!("{:#}", i.for_.print()),
-                    get_id_for_impl_on_foreign_type(&i.for_, trait_),
+                    format!("{:#}", i.for_.print(cache)),
+                    get_id_for_impl_on_foreign_type(&i.for_, trait_, cache),
                 ))
             } else {
                 None
@@ -4570,13 +4577,16 @@ fn sidebar_trait(cx: &Context<'_>, buf: &mut Buffer, it: &clean::Item, t: &clean
         ));
     }
 
-    let c = cache();
-
-    if let Some(implementors) = c.implementors.get(&it.def_id) {
+    if let Some(implementors) = cx.cache.implementors.get(&it.def_id) {
         let mut res = implementors
             .iter()
-            .filter(|i| i.inner_impl().for_.def_id().map_or(false, |d| !c.paths.contains_key(&d)))
-            .filter_map(|i| extract_for_impl_name(&i.impl_item))
+            .filter(|i| {
+                i.inner_impl()
+                    .for_
+                    .def_id_full(cx.cache())
+                    .map_or(false, |d| !cx.cache.paths.contains_key(&d))
+            })
+            .filter_map(|i| extract_for_impl_name(&i.impl_item, cx.cache()))
             .collect::>();
 
         if !res.is_empty() {
@@ -4815,9 +4825,9 @@ fn item_proc_macro(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, m: &clean
     document(w, cx, it, None)
 }
 
-fn item_primitive(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item, cache: &Cache) {
+fn item_primitive(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item) {
     document(w, cx, it, None);
-    render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All, cache)
+    render_assoc_items(w, cx, it, it.def_id, AssocItemRender::All)
 }
 
 fn item_keyword(w: &mut Buffer, cx: &Context<'_>, it: &clean::Item) {
@@ -4836,11 +4846,10 @@ fn make_item_keywords(it: &clean::Item) -> String {
 /// 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) -> Vec {
+fn collect_paths_for_type(first_ty: clean::Type, cache: &Cache) -> Vec {
     let mut out = Vec::new();
     let mut visited = FxHashSet::default();
     let mut work = VecDeque::new();
-    let cache = cache();
 
     work.push_back(first_ty);
 
diff --git a/src/librustdoc/json/mod.rs b/src/librustdoc/json/mod.rs
index 512c9124727ef..a8a4b74b818b6 100644
--- a/src/librustdoc/json/mod.rs
+++ b/src/librustdoc/json/mod.rs
@@ -32,6 +32,7 @@ crate struct JsonRenderer<'tcx> {
     index: Rc>>,
     /// The directory where the blob will be written to.
     out_path: PathBuf,
+    cache: Rc,
 }
 
 impl JsonRenderer<'_> {
@@ -39,12 +40,8 @@ impl JsonRenderer<'_> {
         self.tcx.sess
     }
 
-    fn get_trait_implementors(
-        &mut self,
-        id: rustc_span::def_id::DefId,
-        cache: &Cache,
-    ) -> Vec {
-        cache
+    fn get_trait_implementors(&mut self, id: rustc_span::def_id::DefId) -> Vec {
+        Rc::clone(&self.cache)
             .implementors
             .get(&id)
             .map(|implementors| {
@@ -52,7 +49,7 @@ impl JsonRenderer<'_> {
                     .iter()
                     .map(|i| {
                         let item = &i.impl_item;
-                        self.item(item.clone(), cache).unwrap();
+                        self.item(item.clone()).unwrap();
                         item.def_id.into()
                     })
                     .collect()
@@ -60,8 +57,8 @@ impl JsonRenderer<'_> {
             .unwrap_or_default()
     }
 
-    fn get_impls(&mut self, id: rustc_span::def_id::DefId, cache: &Cache) -> Vec {
-        cache
+    fn get_impls(&mut self, id: rustc_span::def_id::DefId) -> Vec {
+        Rc::clone(&self.cache)
             .impls
             .get(&id)
             .map(|impls| {
@@ -70,7 +67,7 @@ impl JsonRenderer<'_> {
                     .filter_map(|i| {
                         let item = &i.impl_item;
                         if item.def_id.is_local() {
-                            self.item(item.clone(), cache).unwrap();
+                            self.item(item.clone()).unwrap();
                             Some(item.def_id.into())
                         } else {
                             None
@@ -81,24 +78,25 @@ impl JsonRenderer<'_> {
             .unwrap_or_default()
     }
 
-    fn get_trait_items(&mut self, cache: &Cache) -> Vec<(types::Id, types::Item)> {
-        cache
+    fn get_trait_items(&mut self) -> Vec<(types::Id, types::Item)> {
+        Rc::clone(&self.cache)
             .traits
             .iter()
             .filter_map(|(&id, trait_item)| {
                 // only need to synthesize items for external traits
                 if !id.is_local() {
-                    trait_item.items.clone().into_iter().for_each(|i| self.item(i, cache).unwrap());
+                    trait_item.items.clone().into_iter().for_each(|i| self.item(i).unwrap());
                     Some((
                         id.into(),
                         types::Item {
                             id: id.into(),
                             crate_id: id.krate.as_u32(),
-                            name: cache
+                            name: self
+                                .cache
                                 .paths
                                 .get(&id)
                                 .unwrap_or_else(|| {
-                                    cache
+                                    self.cache
                                         .external_paths
                                         .get(&id)
                                         .expect("Trait should either be in local or external paths")
@@ -134,7 +132,7 @@ impl<'tcx> FormatRenderer<'tcx> for JsonRenderer<'tcx> {
         options: RenderOptions,
         _render_info: RenderInfo,
         _edition: Edition,
-        _cache: &mut Cache,
+        cache: Cache,
         tcx: TyCtxt<'tcx>,
     ) -> Result<(Self, clean::Crate), Error> {
         debug!("Initializing json renderer");
@@ -143,6 +141,7 @@ impl<'tcx> FormatRenderer<'tcx> for JsonRenderer<'tcx> {
                 tcx,
                 index: Rc::new(RefCell::new(FxHashMap::default())),
                 out_path: options.output,
+                cache: Rc::new(cache),
             },
             krate,
         ))
@@ -151,18 +150,18 @@ impl<'tcx> FormatRenderer<'tcx> for JsonRenderer<'tcx> {
     /// Inserts an item into the index. This should be used rather than directly calling insert on
     /// the hashmap because certain items (traits and types) need to have their mappings for trait
     /// implementations filled out before they're inserted.
-    fn item(&mut self, item: clean::Item, cache: &Cache) -> Result<(), Error> {
+    fn item(&mut self, item: clean::Item) -> Result<(), Error> {
         // Flatten items that recursively store other items
-        item.kind.inner_items().for_each(|i| self.item(i.clone(), cache).unwrap());
+        item.kind.inner_items().for_each(|i| self.item(i.clone()).unwrap());
 
         let id = item.def_id;
         if let Some(mut new_item) = self.convert_item(item) {
             if let types::ItemEnum::TraitItem(ref mut t) = new_item.inner {
-                t.implementors = self.get_trait_implementors(id, cache)
+                t.implementors = self.get_trait_implementors(id)
             } else if let types::ItemEnum::StructItem(ref mut s) = new_item.inner {
-                s.impls = self.get_impls(id, cache)
+                s.impls = self.get_impls(id)
             } else if let types::ItemEnum::EnumItem(ref mut e) = new_item.inner {
-                e.impls = self.get_impls(id, cache)
+                e.impls = self.get_impls(id)
             }
             let removed = self.index.borrow_mut().insert(id.into(), new_item.clone());
             // FIXME(adotinthevoid): Currently, the index is duplicated. This is a sanity check
@@ -175,27 +174,20 @@ impl<'tcx> FormatRenderer<'tcx> for JsonRenderer<'tcx> {
         Ok(())
     }
 
-    fn mod_item_in(
-        &mut self,
-        item: &clean::Item,
-        _module_name: &str,
-        cache: &Cache,
-    ) -> Result<(), Error> {
+    fn mod_item_in(&mut self, item: &clean::Item, _module_name: &str) -> Result<(), Error> {
         use clean::types::ItemKind::*;
         if let ModuleItem(m) = &*item.kind {
             for item in &m.items {
                 match &*item.kind {
                     // These don't have names so they don't get added to the output by default
-                    ImportItem(_) => self.item(item.clone(), cache).unwrap(),
-                    ExternCrateItem(_, _) => self.item(item.clone(), cache).unwrap(),
-                    ImplItem(i) => {
-                        i.items.iter().for_each(|i| self.item(i.clone(), cache).unwrap())
-                    }
+                    ImportItem(_) => self.item(item.clone()).unwrap(),
+                    ExternCrateItem(_, _) => self.item(item.clone()).unwrap(),
+                    ImplItem(i) => i.items.iter().for_each(|i| self.item(i.clone()).unwrap()),
                     _ => {}
                 }
             }
         }
-        self.item(item.clone(), cache).unwrap();
+        self.item(item.clone()).unwrap();
         Ok(())
     }
 
@@ -206,22 +198,22 @@ impl<'tcx> FormatRenderer<'tcx> for JsonRenderer<'tcx> {
     fn after_krate(
         &mut self,
         krate: &clean::Crate,
-        cache: &Cache,
         _diag: &rustc_errors::Handler,
     ) -> Result<(), Error> {
         debug!("Done with crate");
         let mut index = (*self.index).clone().into_inner();
-        index.extend(self.get_trait_items(cache));
+        index.extend(self.get_trait_items());
         let output = types::Crate {
             root: types::Id(String::from("0:0")),
             crate_version: krate.version.clone(),
-            includes_private: cache.document_private,
+            includes_private: self.cache.document_private,
             index,
-            paths: cache
+            paths: self
+                .cache
                 .paths
                 .clone()
                 .into_iter()
-                .chain(cache.external_paths.clone().into_iter())
+                .chain(self.cache.external_paths.clone().into_iter())
                 .map(|(k, (path, kind))| {
                     (
                         k.into(),
@@ -229,7 +221,8 @@ impl<'tcx> FormatRenderer<'tcx> for JsonRenderer<'tcx> {
                     )
                 })
                 .collect(),
-            external_crates: cache
+            external_crates: self
+                .cache
                 .extern_locations
                 .iter()
                 .map(|(k, v)| {
@@ -254,4 +247,8 @@ impl<'tcx> FormatRenderer<'tcx> for JsonRenderer<'tcx> {
         serde_json::ser::to_writer(&file, &output).unwrap();
         Ok(())
     }
+
+    fn cache(&self) -> &Cache {
+        &self.cache
+    }
 }
diff --git a/src/librustdoc/passes/calculate_doc_coverage.rs b/src/librustdoc/passes/calculate_doc_coverage.rs
index 05a3a15adac80..61e14c0522277 100644
--- a/src/librustdoc/passes/calculate_doc_coverage.rs
+++ b/src/librustdoc/passes/calculate_doc_coverage.rs
@@ -218,7 +218,12 @@ impl<'a, 'b> fold::DocFolder for CoverageCalculator<'a, 'b> {
             clean::ImplItem(ref impl_) => {
                 let filename = i.source.filename(self.ctx.sess());
                 if let Some(ref tr) = impl_.trait_ {
-                    debug!("impl {:#} for {:#} in {}", tr.print(), impl_.for_.print(), filename,);
+                    debug!(
+                        "impl {:#} for {:#} in {}",
+                        tr.print(&self.ctx.cache),
+                        impl_.for_.print(&self.ctx.cache),
+                        filename,
+                    );
 
                     // don't count trait impls, the missing-docs lint doesn't so we shouldn't
                     // either
@@ -227,7 +232,7 @@ impl<'a, 'b> fold::DocFolder for CoverageCalculator<'a, 'b> {
                     // inherent impls *can* be documented, and those docs show up, but in most
                     // cases it doesn't make sense, as all methods on a type are in one single
                     // impl block
-                    debug!("impl {:#} in {}", impl_.for_.print(), filename);
+                    debug!("impl {:#} in {}", impl_.for_.print(&self.ctx.cache), filename);
                 }
             }
             _ => {
diff --git a/src/test/rustdoc-js-std/primitive.js b/src/test/rustdoc-js-std/primitive.js
new file mode 100644
index 0000000000000..e5690383e4f0b
--- /dev/null
+++ b/src/test/rustdoc-js-std/primitive.js
@@ -0,0 +1,75 @@
+const QUERY = [
+    'i8',
+    'u32',
+    'str',
+    'char',
+    'unit',
+    'tuple',
+    'fn',
+];
+
+const EXPECTED = [
+    {
+        'others': [
+            {
+                'path': 'std',
+                'name': 'i8',
+                'href': '../std/primitive.i8.html',
+            },
+        ]
+    },
+    {
+        'others': [
+            {
+                'path': 'std',
+                'name': 'u32',
+                'href': '../std/primitive.u32.html',
+            },
+        ]
+    },
+    {
+        'others': [
+            {
+                'path': 'std',
+                'name': 'str',
+                'href': '../std/primitive.str.html',
+            },
+        ]
+    },
+    {
+        'others': [
+            {
+                'path': 'std',
+                'name': 'char',
+                'href': '../std/primitive.char.html',
+            },
+        ]
+    },
+    {
+        'others': [
+            {
+                'path': 'std',
+                'name': 'unit',
+                'href': '../std/primitive.unit.html',
+            },
+        ]
+    },
+    {
+        'others': [
+            {
+                'path': 'std',
+                'name': 'tuple',
+                'href': '../std/primitive.tuple.html',
+            },
+        ]
+    },
+    {
+        'others': [
+            {
+                'path': 'std',
+                'name': 'fn',
+                'href': '../std/primitive.fn.html',
+            },
+        ]
+    },
+];