take namespace into consideration when doing shadowing

Signed-off-by: longfangsong <longfangsong@icloud.com>

Author: longfangsong

src/librustdoc/doctree.rs

@@ -11,8 +11,10 @@ crate struct Item<'hir> {
     crate hir_item: &'hir hir::Item<'hir>,
     /// the explicit renamed name
     crate renamed_name: Option<Symbol>,
+    /// the [`Namespace`] this Item belongs to
+    crate namespace: Option<hir::def::Namespace>,
     /// whether the item is from a glob import
-    /// if `from_glob` is true and we see another item with same name,
+    /// if `from_glob` is true and we see another item with same name and namespace,
     /// then this item can be replaced with that one
     crate from_glob: bool,
 }
@@ -21,9 +23,10 @@ impl<'hir> Item<'hir> {
     pub(crate) fn new(
         hir_item: &'hir hir::Item<'hir>,
         renamed_name: Option<Symbol>,
+        namespace: Option<hir::def::Namespace>,
         from_glob: bool,
     ) -> Self {
-        Self { hir_item, renamed_name, from_glob }
+        Self { hir_item, renamed_name, namespace, from_glob }
     }
 
     pub(crate) fn name(&self) -> Symbol {
@@ -43,7 +46,7 @@ crate struct Module<'hir> {
     crate is_crate: bool,
     /// whether the module is from a glob import
     /// if `from_glob` is true and we see another module with same name,
-    /// then this item can be replaced with that one
+    /// then this module can be replaced with that one
     crate from_glob: bool,
 }
 
@@ -64,25 +67,29 @@ impl Module<'hir> {
     }
 
     pub(crate) fn push_item(&mut self, new_item: Item<'hir>) {
-        if !new_item.name().is_empty() {
-            // todo: also check namespace
-            if let Some(existing_item) =
-                self.items.iter_mut().find(|item| item.name() == new_item.name())
+        if !new_item.name().is_empty() && new_item.namespace.is_some() {
+            if let Some(existing_item) = self
+                .items
+                .iter_mut()
+                .find(|item| item.name() == new_item.name() && item.namespace == new_item.namespace)
             {
                 match (existing_item.from_glob, new_item.from_glob) {
                     (true, _) => {
-                        // `existing_item` is from glob, no matter whether `new_item` is from glob
+                        // `existing_item` is from glob, no matter whether `new_item` is from glob,
                         // `new_item` should always shadow `existing_item`
                         debug!("push_item: {:?} shadowed by {:?}", existing_item, new_item);
                         *existing_item = new_item;
                         return;
                     }
                     (false, true) => {
-                        // `existing_item` is not from glob but `new_item` is
+                        // `existing_item` is not from glob but `new_item` is,
                         // just keep `existing_item` and return at once
                         return;
                     }
-                    (false, false) => unreachable!() // todo: how to handle this?
+                    (false, false) => {
+                        // should report "defined multiple time" error before reach this
+                        unreachable!()
+                    }
                 }
             }
         }
@@ -94,18 +101,21 @@ impl Module<'hir> {
         if let Some(existing_mod) = self.mods.iter_mut().find(|mod_| mod_.name == new_mod.name) {
             match (existing_mod.from_glob, new_mod.from_glob) {
                 (true, _) => {
-                    // `existing_mod` is from glob, no matter whether `new_mod` is from glob
+                    // `existing_mod` is from glob, no matter whether `new_mod` is from glob,
                     // `new_mod` should always shadow `existing_mod`
                     debug!("push_mod: {:?} shadowed by {:?}", existing_mod.name, new_mod.name);
                     *existing_mod = new_mod;
                     return;
-                },
+                }
                 (false, true) => {
-                    // `existing_mod` is not from glob but `new_mod` is
+                    // `existing_mod` is not from glob but `new_mod` is,
                     // just keep `existing_mod` and return at once
                     return;
-                },
-                (false, false) => unreachable!(),
+                }
+                (false, false) => {
+                    // should report "defined multiple time" error before reach this
+                    unreachable!()
+                }
             }
         }
         // no mod with same name exists, just collect `new_mod`

src/librustdoc/visit_ast.rs

@@ -313,7 +313,12 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
                     }
                 }
 
-                om.push_item(Item::new(item, renamed, from_glob))
+                om.push_item(Item::new(
+                    item,
+                    renamed,
+                    self.cx.tcx.def_kind(item.def_id).ns(),
+                    from_glob,
+                ))
             }
             hir::ItemKind::Mod(ref m) => {
                 om.push_mod(self.visit_mod_contents(
@@ -334,19 +339,34 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
             | hir::ItemKind::OpaqueTy(..)
             | hir::ItemKind::Static(..)
             | hir::ItemKind::Trait(..)
-            | hir::ItemKind::TraitAlias(..) => om.push_item(Item::new(item, renamed, from_glob)),
+            | hir::ItemKind::TraitAlias(..) => om.push_item(Item::new(
+                item,
+                renamed,
+                self.cx.tcx.def_kind(item.def_id).ns(),
+                from_glob,
+            )),
             hir::ItemKind::Const(..) => {
                 // Underscore constants do not correspond to a nameable item and
                 // so are never useful in documentation.
                 if name != kw::Underscore {
-                    om.push_item(Item::new(item, renamed, from_glob));
+                    om.push_item(Item::new(
+                        item,
+                        renamed,
+                        self.cx.tcx.def_kind(item.def_id).ns(),
+                        from_glob,
+                    ));
                 }
             }
             hir::ItemKind::Impl(ref impl_) => {
                 // Don't duplicate impls when inlining or if it's implementing a trait, we'll pick
                 // them up regardless of where they're located.
                 if !self.inlining && impl_.of_trait.is_none() {
-                    om.push_item(Item::new(item, None, from_glob));
+                    om.push_item(Item::new(
+                        item,
+                        None,
+                        self.cx.tcx.def_kind(item.def_id).ns(),
+                        from_glob,
+                    ));
                 }
             }
         }

src/test/rustdoc/glob-shadowing.rs

@@ -40,3 +40,5 @@ pub use sub2::describe;
 
 #[doc(inline)]
 pub use sub1::*;
+
+pub fn describe() {}