Introduce OwnerNode::Crate.

compiler/rustc_hir/src/arena.rs

@@ -36,6 +36,7 @@ macro_rules! arena_types {
             [few] llvm_inline_asm: rustc_hir::LlvmInlineAsm<$tcx>,
             [] local: rustc_hir::Local<$tcx>,
             [few] macro_def: rustc_hir::MacroDef<$tcx>,
+            [few] mod_: rustc_hir::Mod<$tcx>,
             [] param: rustc_hir::Param<$tcx>,
             [] pat: rustc_hir::Pat<$tcx>,
             [] path: rustc_hir::Path<$tcx>,

compiler/rustc_hir/src/hir.rs

@@ -1,6 +1,6 @@
 // ignore-tidy-filelength
 use crate::def::{CtorKind, DefKind, Res};
-use crate::def_id::DefId;
+use crate::def_id::{DefId, CRATE_DEF_ID};
 crate use crate::hir_id::{HirId, ItemLocalId};
 use crate::{itemlikevisit, LangItem};
 
@@ -628,7 +628,6 @@ pub struct ModuleItems {
 /// [rustc dev guide]: https://rustc-dev-guide.rust-lang.org/hir.html
 #[derive(Debug)]
 pub struct Crate<'hir> {
-    pub item: Mod<'hir>,
     // Attributes from non-exported macros, kept only for collecting the library feature list.
     pub non_exported_macro_attrs: &'hir [Attribute],
 
@@ -658,6 +657,10 @@ pub struct Crate<'hir> {
 }
 
 impl Crate<'hir> {
+    pub fn module(&self) -> &'hir Mod<'hir> {
+        if let Some(OwnerNode::Crate(m)) = self.owners[CRATE_DEF_ID] { m } else { panic!() }
+    }
+
     pub fn item(&self, id: ItemId) -> &'hir Item<'hir> {
         self.owners[id.def_id].as_ref().unwrap().expect_item()
     }
@@ -698,7 +701,7 @@ impl Crate<'_> {
                 OwnerNode::ForeignItem(item) => visitor.visit_foreign_item(item),
                 OwnerNode::ImplItem(item) => visitor.visit_impl_item(item),
                 OwnerNode::TraitItem(item) => visitor.visit_trait_item(item),
-                OwnerNode::MacroDef(_) => {}
+                OwnerNode::MacroDef(_) | OwnerNode::Crate(_) => {}
             }
         }
     }
@@ -713,7 +716,7 @@ impl Crate<'_> {
             Some(OwnerNode::ForeignItem(item)) => visitor.visit_foreign_item(item),
             Some(OwnerNode::ImplItem(item)) => visitor.visit_impl_item(item),
             Some(OwnerNode::TraitItem(item)) => visitor.visit_trait_item(item),
-            Some(OwnerNode::MacroDef(_)) | None => {}
+            Some(OwnerNode::MacroDef(_)) | Some(OwnerNode::Crate(_)) | None => {}
         })
     }
 
@@ -2943,16 +2946,29 @@ pub enum OwnerNode<'hir> {
     TraitItem(&'hir TraitItem<'hir>),
     ImplItem(&'hir ImplItem<'hir>),
     MacroDef(&'hir MacroDef<'hir>),
+    Crate(&'hir Mod<'hir>),
 }
 
 impl<'hir> OwnerNode<'hir> {
-    pub fn ident(&self) -> Ident {
+    pub fn ident(&self) -> Option<Ident> {
         match self {
             OwnerNode::Item(Item { ident, .. })
             | OwnerNode::ForeignItem(ForeignItem { ident, .. })
             | OwnerNode::ImplItem(ImplItem { ident, .. })
             | OwnerNode::TraitItem(TraitItem { ident, .. })
-            | OwnerNode::MacroDef(MacroDef { ident, .. }) => *ident,
+            | OwnerNode::MacroDef(MacroDef { ident, .. }) => Some(*ident),
+            OwnerNode::Crate(..) => None,
+        }
+    }
+
+    pub fn span(&self) -> Span {
+        match self {
+            OwnerNode::Item(Item { span, .. })
+            | OwnerNode::ForeignItem(ForeignItem { span, .. })
+            | OwnerNode::ImplItem(ImplItem { span, .. })
+            | OwnerNode::TraitItem(TraitItem { span, .. })
+            | OwnerNode::MacroDef(MacroDef { span, .. })
+            | OwnerNode::Crate(Mod { inner: span, .. }) => *span,
         }
     }
 
@@ -2997,56 +3013,42 @@ impl<'hir> OwnerNode<'hir> {
             | OwnerNode::ImplItem(ImplItem { def_id, .. })
             | OwnerNode::ForeignItem(ForeignItem { def_id, .. })
             | OwnerNode::MacroDef(MacroDef { def_id, .. }) => *def_id,
+            OwnerNode::Crate(..) => crate::CRATE_HIR_ID.owner,
         }
     }
 
     pub fn expect_item(self) -> &'hir Item<'hir> {
         match self {
             OwnerNode::Item(n) => n,
-            OwnerNode::ForeignItem(_)
-            | OwnerNode::ImplItem(_)
-            | OwnerNode::TraitItem(_)
-            | OwnerNode::MacroDef(_) => panic!(),
+            _ => panic!(),
         }
     }
 
     pub fn expect_foreign_item(self) -> &'hir ForeignItem<'hir> {
         match self {
             OwnerNode::ForeignItem(n) => n,
-            OwnerNode::Item(_)
-            | OwnerNode::ImplItem(_)
-            | OwnerNode::TraitItem(_)
-            | OwnerNode::MacroDef(_) => panic!(),
+            _ => panic!(),
         }
     }
 
     pub fn expect_impl_item(self) -> &'hir ImplItem<'hir> {
         match self {
             OwnerNode::ImplItem(n) => n,
-            OwnerNode::ForeignItem(_)
-            | OwnerNode::Item(_)
-            | OwnerNode::TraitItem(_)
-            | OwnerNode::MacroDef(_) => panic!(),
+            _ => panic!(),
         }
     }
 
     pub fn expect_trait_item(self) -> &'hir TraitItem<'hir> {
         match self {
             OwnerNode::TraitItem(n) => n,
-            OwnerNode::ForeignItem(_)
-            | OwnerNode::ImplItem(_)
-            | OwnerNode::Item(_)
-            | OwnerNode::MacroDef(_) => panic!(),
+            _ => panic!(),
         }
     }
 
     pub fn expect_macro_def(self) -> &'hir MacroDef<'hir> {
         match self {
             OwnerNode::MacroDef(n) => n,
-            OwnerNode::ForeignItem(_)
-            | OwnerNode::ImplItem(_)
-            | OwnerNode::TraitItem(_)
-            | OwnerNode::Item(_) => panic!(),
+            _ => panic!(),
         }
     }
 }
@@ -3089,6 +3091,7 @@ impl<'hir> Into<Node<'hir>> for OwnerNode<'hir> {
             OwnerNode::ImplItem(n) => Node::ImplItem(n),
             OwnerNode::TraitItem(n) => Node::TraitItem(n),
             OwnerNode::MacroDef(n) => Node::MacroDef(n),
+            OwnerNode::Crate(n) => Node::Crate(n),
         }
     }
 }
@@ -3221,6 +3224,18 @@ impl<'hir> Node<'hir> {
             _ => Constness::NotConst,
         }
     }
+
+    pub fn as_owner(self) -> Option<OwnerNode<'hir>> {
+        match self {
+            Node::Item(i) => Some(OwnerNode::Item(i)),
+            Node::ForeignItem(i) => Some(OwnerNode::ForeignItem(i)),
+            Node::TraitItem(i) => Some(OwnerNode::TraitItem(i)),
+            Node::ImplItem(i) => Some(OwnerNode::ImplItem(i)),
+            Node::MacroDef(i) => Some(OwnerNode::MacroDef(i)),
+            Node::Crate(i) => Some(OwnerNode::Crate(i)),
+            _ => None,
+        }
+    }
 }
 
 // Some nodes are used a lot. Make sure they don't unintentionally get bigger.

compiler/rustc_hir/src/intravisit.rs

@@ -478,7 +478,8 @@ pub trait Visitor<'v>: Sized {
 
 /// Walks the contents of a crate. See also `Crate::visit_all_items`.
 pub fn walk_crate<'v, V: Visitor<'v>>(visitor: &mut V, krate: &'v Crate<'v>) {
-    visitor.visit_mod(&krate.item, krate.item.inner, CRATE_HIR_ID);
+    let top_mod = krate.module();
+    visitor.visit_mod(top_mod, top_mod.inner, CRATE_HIR_ID);
     walk_list!(visitor, visit_macro_def, krate.exported_macros());
     for (&id, attrs) in krate.attrs.iter() {
         for a in *attrs {