Move primitive_locations build before the crate.clean

GuillaumeGomez · GuillaumeGomez · commit 374f9b5c3920 · 2020-07-31T23:22:34.000+02:00
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
@@ -28,12 +28,10 @@ use rustc_span::symbol::{kw, sym, Ident, Symbol};
 use rustc_span::{self, Pos};
 use rustc_typeck::hir_ty_to_ty;
 
-use std::cell::RefCell;
 use std::collections::hash_map::Entry;
 use std::default::Default;
 use std::hash::Hash;
 use std::rc::Rc;
-use std::sync::Arc;
 use std::{mem, vec};
 
 use crate::core::{self, DocContext, ImplTraitParam};
@@ -50,13 +48,6 @@ pub use self::types::Type::*;
 pub use self::types::Visibility::{Inherited, Public};
 pub use self::types::*;
 
-thread_local!(static PRIMITIVES: RefCell<Arc<FxHashMap<PrimitiveType, DefId>>> =
-    Default::default());
-
-crate fn primitives() -> Arc<FxHashMap<PrimitiveType, DefId>> {
-    PRIMITIVES.with(|c| c.borrow().clone())
-}
-
 const FN_OUTPUT_NAME: &str = "Output";
 
 pub trait Clean<T> {
@@ -93,48 +84,49 @@ impl<T: Clean<U>, U> Clean<Option<U>> for Option<T> {
     }
 }
 
+/// Collect all inner modules which are tagged as implementations of
+/// primitives.
+///
+/// Note that this loop only searches the top-level items of the crate,
+/// and this is intentional. If we were to search the entire crate for an
+/// item tagged with `#[doc(primitive)]` then we would also have to
+/// search the entirety of external modules for items tagged
+/// `#[doc(primitive)]`, which is a pretty inefficient process (decoding
+/// all that metadata unconditionally).
+///
+/// In order to keep the metadata load under control, the
+/// `#[doc(primitive)]` feature is explicitly designed to only allow the
+/// primitive tags to show up as the top level items in a crate.
+///
+/// Also note that this does not attempt to deal with modules tagged
+/// duplicately for the same primitive. This is handled later on when
+/// rendering by delegating everything to a hash map.
+crate fn as_primitive(cx: &DocContext<'_>, res: Res) -> Option<(DefId, PrimitiveType, Attributes)> {
+    if let Res::Def(DefKind::Mod, def_id) = res {
+        let attrs = cx.tcx.get_attrs(def_id).clean(cx);
+        let mut prim = None;
+        for attr in attrs.lists(sym::doc) {
+            if let Some(v) = attr.value_str() {
+                if attr.check_name(sym::primitive) {
+                    prim = PrimitiveType::from_symbol(v);
+                    if prim.is_some() {
+                        break;
+                    }
+                    // FIXME: should warn on unknown primitives?
+                }
+            }
+        }
+        return prim.map(|p| (def_id, p, attrs));
+    }
+    None
+}
+
 impl Clean<ExternalCrate> for CrateNum {
     fn clean(&self, cx: &DocContext<'_>) -> ExternalCrate {
         let root = DefId { krate: *self, index: CRATE_DEF_INDEX };
         let krate_span = cx.tcx.def_span(root);
         let krate_src = cx.sess().source_map().span_to_filename(krate_span);
 
-        // Collect all inner modules which are tagged as implementations of
-        // primitives.
-        //
-        // Note that this loop only searches the top-level items of the crate,
-        // and this is intentional. If we were to search the entire crate for an
-        // item tagged with `#[doc(primitive)]` then we would also have to
-        // search the entirety of external modules for items tagged
-        // `#[doc(primitive)]`, which is a pretty inefficient process (decoding
-        // all that metadata unconditionally).
-        //
-        // In order to keep the metadata load under control, the
-        // `#[doc(primitive)]` feature is explicitly designed to only allow the
-        // primitive tags to show up as the top level items in a crate.
-        //
-        // Also note that this does not attempt to deal with modules tagged
-        // duplicately for the same primitive. This is handled later on when
-        // rendering by delegating everything to a hash map.
-        let as_primitive = |res: Res| {
-            if let Res::Def(DefKind::Mod, def_id) = res {
-                let attrs = cx.tcx.get_attrs(def_id).clean(cx);
-                let mut prim = None;
-                for attr in attrs.lists(sym::doc) {
-                    if let Some(v) = attr.value_str() {
-                        if attr.check_name(sym::primitive) {
-                            prim = PrimitiveType::from_symbol(v);
-                            if prim.is_some() {
-                                break;
-                            }
-                            // FIXME: should warn on unknown primitives?
-                        }
-                    }
-                }
-                return prim.map(|p| (def_id, p, attrs));
-            }
-            None
-        };
         let primitives: Vec<(DefId, PrimitiveType, Attributes)> = if root.is_local() {
             cx.tcx
                 .hir()
@@ -146,14 +138,14 @@ impl Clean<ExternalCrate> for CrateNum {
                 .filter_map(|&id| {
                     let item = cx.tcx.hir().expect_item(id.id);
                     match item.kind {
-                        hir::ItemKind::Mod(_) => as_primitive(Res::Def(
-                            DefKind::Mod,
-                            cx.tcx.hir().local_def_id(id.id).to_def_id(),
-                        )),
+                        hir::ItemKind::Mod(_) => as_primitive(
+                            cx,
+                            Res::Def(DefKind::Mod, cx.tcx.hir().local_def_id(id.id).to_def_id()),
+                        ),
                         hir::ItemKind::Use(ref path, hir::UseKind::Single)
                             if item.vis.node.is_pub() =>
                         {
-                            as_primitive(path.res).map(|(_, prim, attrs)| {
+                            as_primitive(cx, path.res).map(|(_, prim, attrs)| {
                                 // Pretend the primitive is local.
                                 (cx.tcx.hir().local_def_id(id.id).to_def_id(), prim, attrs)
                             })
@@ -167,16 +159,9 @@ impl Clean<ExternalCrate> for CrateNum {
                 .item_children(root)
                 .iter()
                 .map(|item| item.res)
-                .filter_map(as_primitive)
+                .filter_map(|res| as_primitive(cx, res))
                 .collect()
         };
-        PRIMITIVES.with(|v| {
-            let mut tmp = v.borrow_mut();
-            let stored_primitives = Arc::make_mut(&mut *tmp);
-            for (prim, did) in primitives.iter().map(|x| (x.1, x.0)) {
-                stored_primitives.insert(prim, did);
-            }
-        });
 
         let as_keyword = |res: Res| {
             if let Res::Def(DefKind::Mod, def_id) = res {
diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
@@ -1173,7 +1173,7 @@ impl GetDefId for Type {
     fn def_id(&self) -> Option<DefId> {
         match *self {
             ResolvedPath { did, .. } => Some(did),
-            Primitive(p) => super::primitives().get(&p).cloned(),
+            Primitive(p) => crate::core::primitives().get(&p).cloned(),
             BorrowedRef { type_: box Generic(..), .. } => {
                 Primitive(PrimitiveType::Reference).def_id()
             }
diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs
@@ -5,7 +5,8 @@ use rustc_driver::abort_on_err;
 use rustc_errors::emitter::{Emitter, EmitterWriter};
 use rustc_errors::json::JsonEmitter;
 use rustc_feature::UnstableFeatures;
-use rustc_hir::def::{Namespace::TypeNS, Res};
+use rustc_hir as hir;
+use rustc_hir::def::{DefKind, Namespace::TypeNS, Res};
 use rustc_hir::def_id::{CrateNum, DefId, DefIndex, LocalDefId, CRATE_DEF_INDEX, LOCAL_CRATE};
 use rustc_hir::HirId;
 use rustc_hir::{
@@ -29,16 +30,25 @@ use rustc_span::DUMMY_SP;
 use std::cell::RefCell;
 use std::mem;
 use std::rc::Rc;
+use std::sync::Arc;
 
 use crate::clean;
-use crate::clean::{AttributesExt, MAX_DEF_ID};
+use crate::clean::types::PrimitiveType;
+use crate::clean::{as_primitive, AttributesExt, MAX_DEF_ID};
 use crate::config::RenderInfo;
 use crate::config::{Options as RustdocOptions, RenderOptions};
 use crate::passes::{self, Condition::*, ConditionalPass};
 
 pub use rustc_session::config::{CodegenOptions, DebuggingOptions, Input, Options};
 pub use rustc_session::search_paths::SearchPath;
 
+thread_local!(static PRIMITIVES: RefCell<Arc<FxHashMap<PrimitiveType, DefId>>> =
+    Default::default());
+
+crate fn primitives() -> Arc<FxHashMap<PrimitiveType, DefId>> {
+    PRIMITIVES.with(|c| c.borrow().clone())
+}
+
 pub type ExternalPaths = FxHashMap<DefId, (Vec<String>, clean::TypeKind)>;
 
 pub struct DocContext<'tcx> {
@@ -499,6 +509,65 @@ pub fn run_core(options: RustdocOptions) -> (clean::Crate, RenderInfo, RenderOpt
                 };
                 debug!("crate: {:?}", tcx.hir().krate());
 
+                PRIMITIVES.with(|v| {
+                    let mut tmp = v.borrow_mut();
+                    let stored_primitives = Arc::make_mut(&mut *tmp);
+
+                    let mut externs = Vec::new();
+                    for &cnum in ctxt.tcx.crates().iter() {
+                        externs.push(cnum);
+                    }
+                    externs.sort_by(|a, b| a.cmp(&b));
+
+                    for krate in externs.iter().chain([LOCAL_CRATE].iter()) {
+                        let root = DefId { krate: *krate, index: CRATE_DEF_INDEX };
+                        let iter: Vec<(DefId, PrimitiveType)> = if root.is_local() {
+                            ctxt.tcx.hir_crate(*krate).item.module.item_ids.iter().filter_map(
+                                |&id| {
+                                    let item = ctxt.tcx.hir().expect_item(id.id);
+                                    match item.kind {
+                                        hir::ItemKind::Mod(_) => as_primitive(
+                                            &ctxt,
+                                            Res::Def(
+                                                DefKind::Mod,
+                                                ctxt.tcx.hir().local_def_id(id.id).to_def_id(),
+                                            ),
+                                        )
+                                        .map(|(did, prim, _)| (did, prim)),
+                                        hir::ItemKind::Use(ref path, hir::UseKind::Single)
+                                            if item.vis.node.is_pub() =>
+                                        {
+                                            as_primitive(&ctxt, path.res).map(|(_, prim, _)| {
+                                                // Pretend the primitive is local.
+                                                (
+                                                    ctxt.tcx
+                                                        .hir()
+                                                        .local_def_id(id.id)
+                                                        .to_def_id(),
+                                                    prim,
+                                                )
+                                            })
+                                        }
+                                        _ => None,
+                                    }
+                                },
+                            )
+                            .collect()
+                        } else {
+                            ctxt
+                                .tcx
+                                .item_children(root)
+                                .iter()
+                                .map(|item| item.res)
+                                .filter_map(|res| as_primitive(&ctxt, res).map(|(did, prim, _)| (did, prim)))
+                                .collect()
+                        };
+                        for (did, prim) in iter {
+                            stored_primitives.insert(prim, did);
+                        }
+                    }
+                });
+
                 let mut krate = clean::krate(&mut ctxt);
 
                 if let Some(ref m) = krate.module {
diff --git a/src/librustdoc/formats/cache.rs b/src/librustdoc/formats/cache.rs
@@ -9,8 +9,9 @@ use rustc_hir::def_id::{CrateNum, DefId, CRATE_DEF_INDEX};
 use rustc_middle::middle::privacy::AccessLevels;
 use rustc_span::source_map::FileName;
 
-use crate::clean::{self, primitives, GetDefId};
+use crate::clean::{self, GetDefId};
 use crate::config::RenderInfo;
+use crate::core::primitives;
 use crate::fold::DocFolder;
 use crate::formats::item_type::ItemType;
 use crate::formats::Impl;
diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs
@@ -14,7 +14,8 @@ use rustc_hir as hir;
 use rustc_span::def_id::DefId;
 use rustc_target::spec::abi::Abi;
 
-use crate::clean::{self, primitives, PrimitiveType};
+use crate::clean::{self, PrimitiveType};
+use crate::core::primitives;
 use crate::formats::cache::cache;
 use crate::formats::item_type::ItemType;
 use crate::html::escape::Escape;
@@ -578,13 +579,21 @@ fn primitive_link(
                 needs_termination = true;
             }
             Some(&def_id) => {
-                let loc = match m.extern_locations[&def_id.krate] {
-                    (ref cname, _, ExternalLocation::Remote(ref s)) => Some((cname, s.to_string())),
-                    (ref cname, _, ExternalLocation::Local) => {
+                let loc = match m.extern_locations.get(&def_id.krate) {
+                    Some((ref cname, _, ExternalLocation::Remote(ref s))) => {
+                        Some((cname.as_str(), s.to_string()))
+                    }
+                    Some((ref cname, _, ExternalLocation::Local)) => {
+                        let len = CURRENT_DEPTH.with(|s| s.get());
+                        Some((cname.as_str(), "../".repeat(len)))
+                    }
+                    Some((.., ExternalLocation::Unknown)) => None,
+                    None => {
+                        // It means we're in core, since the primitive types aren't "accessible"
+                        // from it so we have to simulate it.
                         let len = CURRENT_DEPTH.with(|s| s.get());
-                        Some((cname, "../".repeat(len)))
+                        Some(("core", "../".repeat(len)))
                     }
-                    (.., ExternalLocation::Unknown) => None,
                 };
                 if let Some((cname, root)) = loc {
                     write!(
diff --git a/src/librustdoc/html/render/cache.rs b/src/librustdoc/html/render/cache.rs
@@ -13,6 +13,7 @@ use crate::html::render::{plain_summary_line, shorten};
 use crate::html::render::{Generic, IndexItem, IndexItemFunctionType, RenderType, TypeWithKind};
 
 /// Indicates where an external crate can be found.
+#[derive(Debug)]
 pub enum ExternalLocation {
     /// Remote URL root of the external crate
     Remote(String),
diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs
@@ -63,9 +63,10 @@ use rustc_span::symbol::{sym, Symbol};
 use serde::ser::SerializeSeq;
 use serde::{Serialize, Serializer};
 
-use crate::clean::{self, primitives, AttributesExt, Deprecation, GetDefId, SelfTy, TypeKind};
+use crate::clean::{self, AttributesExt, Deprecation, GetDefId, SelfTy, TypeKind};
 use crate::config::RenderInfo;
 use crate::config::RenderOptions;
+use crate::core::primitives;
 use crate::docfs::{DocFS, PathError};
 use crate::doctree;
 use crate::error::Error;

Original file line number	Diff line number	Diff line change
`@@ -1173,7 +1173,7 @@ impl GetDefId for Type {`
`1173`	`1173`	`fn def_id(&self) -> Option<DefId> {`
`1174`	`1174`	`match *self {`
`1175`	`1175`	`ResolvedPath { did, .. } => Some(did),`
`1176`		`- Primitive(p) => super::primitives().get(&p).cloned(),`
	`1176`	`+ Primitive(p) => crate::core::primitives().get(&p).cloned(),`
`1177`	`1177`	`BorrowedRef { type_: box Generic(..), .. } => {`
`1178`	`1178`	`Primitive(PrimitiveType::Reference).def_id()`
`1179`	`1179`	`}`