Remove CACHE_KEY global

Author: GuillaumeGomez

src/librustdoc/clean/inline.rs

@@ -368,7 +368,7 @@ crate fn build_impl(
     // Only inline impl if the implementing type is
     // reachable in rustdoc generated documentation
     if !did.is_local() {
-        if let Some(did) = for_.def_id() {
+        if let Some(did) = for_.def_id(&cx.cache) {
             if !cx.renderinfo.borrow().access_levels.is_public(did) {
                 return;
             }
@@ -410,19 +410,19 @@ crate fn build_impl(
         clean::GenericBound::TraitBound(polyt, _) => polyt.trait_,
         clean::GenericBound::Outlives(..) => unreachable!(),
     });
-    if trait_.def_id() == tcx.lang_items().deref_trait() {
+    if trait_.def_id(&cx.cache) == tcx.lang_items().deref_trait() {
         super::build_deref_target_impls(cx, &trait_items, ret);
     }
-    if let Some(trait_did) = trait_.def_id() {
+    if let Some(trait_did) = trait_.def_id(&cx.cache) {
         record_extern_trait(cx, trait_did);
     }
 
     let provided = trait_
-        .def_id()
+        .def_id(&cx.cache)
         .map(|did| tcx.provided_trait_methods(did).map(|meth| meth.ident.name).collect())
         .unwrap_or_default();
 
-    debug!("build_impl: impl {:?} for {:?}", trait_.def_id(), for_.def_id());
+    debug!("build_impl: impl {:?} for {:?}", trait_.def_id(&cx.cache), for_.def_id(&cx.cache));
 
     let mut item = clean::Item::from_def_id_and_parts(
         did,

src/librustdoc/clean/mod.rs

@@ -2089,17 +2089,17 @@ fn clean_impl(impl_: &hir::Impl<'_>, hir_id: hir::HirId, cx: &DocContext<'_>) ->
 
     // If this impl block is an implementation of the Deref trait, then we
     // need to try inlining the target's inherent impl blocks as well.
-    if trait_.def_id() == cx.tcx.lang_items().deref_trait() {
+    if trait_.def_id(&cx.cache) == cx.tcx.lang_items().deref_trait() {
         build_deref_target_impls(cx, &items, &mut ret);
     }
 
     let provided: FxHashSet<Symbol> = trait_
-        .def_id()
+        .def_id(&cx.cache)
         .map(|did| cx.tcx.provided_trait_methods(did).map(|meth| meth.ident.name).collect())
         .unwrap_or_default();
 
     let for_ = impl_.self_ty.clean(cx);
-    let type_alias = for_.def_id().and_then(|did| match cx.tcx.def_kind(did) {
+    let type_alias = for_.def_id(&cx.cache).and_then(|did| match cx.tcx.def_kind(did) {
         DefKind::TyAlias => Some(cx.tcx.type_of(did).clean(cx)),
         _ => None,
     });
@@ -2329,14 +2329,14 @@ impl Clean<Item> for (&hir::MacroDef<'_>, Option<Symbol>) {
             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::<String>(),
                 )
             } 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()

src/librustdoc/clean/types.rs

@@ -37,7 +37,8 @@ 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::doctree;
+use crate::formats::cache::Cache;
 use crate::formats::item_type::ItemType;
 use crate::html::render::cache::ExternalLocation;
 
@@ -169,8 +170,8 @@ impl Item {
         self.attrs.collapsed_doc_value()
     }
 
-    crate fn links(&self) -> Vec<RenderedLink> {
-        self.attrs.links(&self.def_id.krate)
+    crate fn links(&self, cache: &Cache) -> Vec<RenderedLink> {
+        self.attrs.links(&self.def_id.krate, cache)
     }
 
     crate fn is_crate(&self) -> bool {
@@ -826,7 +827,7 @@ impl Attributes {
     /// Gets links as a vector
     ///
     /// Cache must be populated before call
-    crate fn links(&self, krate: &CrateNum) -> Vec<RenderedLink> {
+    crate fn links(&self, krate: &CrateNum, cache: &Cache) -> Vec<RenderedLink> {
         use crate::html::format::href;
         use crate::html::render::CURRENT_DEPTH;
 
@@ -835,7 +836,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 +852,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());
@@ -958,7 +958,7 @@ impl GenericBound {
     crate fn is_sized_bound(&self, cx: &DocContext<'_>) -> bool {
         use rustc_hir::TraitBoundModifier as TBM;
         if let GenericBound::TraitBound(PolyTrait { ref trait_, .. }, TBM::None) = *self {
-            if trait_.def_id() == cx.tcx.lang_items().sized_trait() {
+            if trait_.def_id(&cx.cache) == cx.tcx.lang_items().sized_trait() {
                 return true;
             }
         }
@@ -1171,9 +1171,9 @@ crate enum FnRetTy {
 }
 
 impl GetDefId for FnRetTy {
-    fn def_id(&self) -> Option<DefId> {
+    fn def_id(&self, cache: &Cache) -> Option<DefId> {
         match *self {
-            Return(ref ty) => ty.def_id(),
+            Return(ref ty) => ty.def_id(cache),
             DefaultReturn => None,
         }
     }
@@ -1299,12 +1299,12 @@ crate enum TypeKind {
 }
 
 crate trait GetDefId {
-    fn def_id(&self) -> Option<DefId>;
+    fn def_id(&self, cache: &Cache) -> Option<DefId>;
 }
 
 impl<T: GetDefId> GetDefId for Option<T> {
-    fn def_id(&self) -> Option<DefId> {
-        self.as_ref().and_then(|d| d.def_id())
+    fn def_id(&self, cache: &Cache) -> Option<DefId> {
+        self.as_ref().and_then(|d| d.def_id(cache))
     }
 }
 
@@ -1394,27 +1394,27 @@ impl Type {
 }
 
 impl GetDefId for Type {
-    fn def_id(&self) -> Option<DefId> {
+    fn def_id(&self, cache: &Cache) -> Option<DefId> {
         match *self {
             ResolvedPath { did, .. } => Some(did),
-            Primitive(p) => cache().primitive_locations.get(&p).cloned(),
+            Primitive(p) => cache.primitive_locations.get(&p).cloned(),
             BorrowedRef { type_: box Generic(..), .. } => {
-                Primitive(PrimitiveType::Reference).def_id()
+                Primitive(PrimitiveType::Reference).def_id(cache)
             }
-            BorrowedRef { ref type_, .. } => type_.def_id(),
+            BorrowedRef { ref type_, .. } => type_.def_id(cache),
             Tuple(ref tys) => {
                 if tys.is_empty() {
-                    Primitive(PrimitiveType::Unit).def_id()
+                    Primitive(PrimitiveType::Unit).def_id(cache)
                 } else {
-                    Primitive(PrimitiveType::Tuple).def_id()
+                    Primitive(PrimitiveType::Tuple).def_id(cache)
                 }
             }
-            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(),
+            BareFunction(..) => Primitive(PrimitiveType::Fn).def_id(cache),
+            Never => Primitive(PrimitiveType::Never).def_id(cache),
+            Slice(..) => Primitive(PrimitiveType::Slice).def_id(cache),
+            Array(..) => Primitive(PrimitiveType::Array).def_id(cache),
+            RawPointer(..) => Primitive(PrimitiveType::RawPointer).def_id(cache),
+            QPath { ref self_type, .. } => self_type.def_id(cache),
             _ => None,
         }
     }
@@ -1814,8 +1814,8 @@ crate struct Typedef {
 }
 
 impl GetDefId for Typedef {
-    fn def_id(&self) -> Option<DefId> {
-        self.type_.def_id()
+    fn def_id(&self, cache: &Cache) -> Option<DefId> {
+        self.type_.def_id(cache)
     }
 }
 

src/librustdoc/clean/utils.rs

@@ -177,9 +177,11 @@ 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(),
+            WherePredicate::BoundPredicate { ty, .. } => {
+                ty.def_id(&cx.cache) == arg.def_id(&cx.cache)
+            }
             _ => false,
         }) {
             let bounds = where_pred.get_bounds().unwrap_or_else(|| &[]);
@@ -195,7 +197,7 @@ crate fn get_real_types(
                                 res.extend(adds);
                             } else if !ty.is_full_generic() {
                                 if let Some(kind) =
-                                    ty.def_id().map(|did| cx.tcx.def_kind(did).clean(cx))
+                                    ty.def_id(&cx.cache).map(|did| cx.tcx.def_kind(did).clean(cx))
                                 {
                                     res.insert((ty, kind));
                                 }
@@ -212,15 +214,17 @@ crate fn get_real_types(
                     if !adds.is_empty() {
                         res.extend(adds);
                     } else if !ty.is_full_generic() {
-                        if let Some(kind) = ty.def_id().map(|did| cx.tcx.def_kind(did).clean(cx)) {
+                        if let Some(kind) =
+                            ty.def_id(&cx.cache).map(|did| cx.tcx.def_kind(did).clean(cx))
+                        {
                             res.insert((ty.clone(), kind));
                         }
                     }
                 }
             }
         }
     } else {
-        if let Some(kind) = arg.def_id().map(|did| cx.tcx.def_kind(did).clean(cx)) {
+        if let Some(kind) = arg.def_id(&cx.cache).map(|did| cx.tcx.def_kind(did).clean(cx)) {
             res.insert((arg.clone(), kind));
         }
         if let Some(gens) = arg.generics() {
@@ -230,7 +234,9 @@ crate fn get_real_types(
                     if !adds.is_empty() {
                         res.extend(adds);
                     }
-                } else if let Some(kind) = gen.def_id().map(|did| cx.tcx.def_kind(did).clean(cx)) {
+                } else if let Some(kind) =
+                    gen.def_id(&cx.cache).map(|did| cx.tcx.def_kind(did).clean(cx))
+                {
                     res.insert((gen.clone(), kind));
                 }
             }
@@ -257,7 +263,9 @@ crate fn get_all_types(
         if !args.is_empty() {
             all_types.extend(args);
         } else {
-            if let Some(kind) = arg.type_.def_id().map(|did| cx.tcx.def_kind(did).clean(cx)) {
+            if let Some(kind) =
+                arg.type_.def_id(&cx.cache).map(|did| cx.tcx.def_kind(did).clean(cx))
+            {
                 all_types.insert((arg.type_.clone(), kind));
             }
         }
@@ -267,7 +275,9 @@ crate fn get_all_types(
         FnRetTy::Return(ref return_type) => {
             let mut ret = get_real_types(generics, &return_type, cx, 0);
             if ret.is_empty() {
-                if let Some(kind) = return_type.def_id().map(|did| cx.tcx.def_kind(did).clean(cx)) {
+                if let Some(kind) =
+                    return_type.def_id(&cx.cache).map(|did| cx.tcx.def_kind(did).clean(cx))
+                {
                     ret.insert((return_type.clone(), kind));
                 }
             }
@@ -473,7 +483,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,

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<DefId>,

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<ParamEnv<'tcx>>,
-    /// Later on moved into `CACHE_KEY`
+    /// Later on moved into `cache`
     crate renderinfo: RefCell<RenderInfo>,
-    /// Later on moved through `clean::Crate` into `CACHE_KEY`
+    /// Later on moved through `clean::Crate` into `cache`
     crate external_traits: Rc<RefCell<FxHashMap<DefId, clean::Trait>>>,
     /// Used while populating `external_traits` to ensure we don't process the same trait twice at
     /// the same time.
@@ -75,6 +76,8 @@ crate struct DocContext<'tcx> {
     /// See `collect_intra_doc_links::traits_implemented_by` for more details.
     /// `map<module, set<trait>>`
     crate module_trait_cache: RefCell<FxHashMap<DefId, FxHashSet<DefId>>>,
+    /// 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());