compiler/rustc_middle/src/hir/map/mod.rs

   1 use crate::hir::{ModuleItems, Owner};
   2 use crate::ty::TyCtxt;
   3 use rustc_ast as ast;
   4 use rustc_data_structures::fingerprint::Fingerprint;
   5 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
   6 use rustc_data_structures::svh::Svh;
   7 use rustc_data_structures::sync::{par_for_each_in, Send, Sync};
   8 use rustc_hir::def::{DefKind, Res};
   9 use rustc_hir::def_id::{CrateNum, DefId, LocalDefId, CRATE_DEF_ID, LOCAL_CRATE};
  10 use rustc_hir::definitions::{DefKey, DefPath, DefPathHash};
  11 use rustc_hir::intravisit::{self, Visitor};
  12 use rustc_hir::itemlikevisit::ItemLikeVisitor;
  13 use rustc_hir::*;
  14 use rustc_index::vec::Idx;
  15 use rustc_span::def_id::StableCrateId;
  16 use rustc_span::hygiene::MacroKind;
  17 use rustc_span::source_map::Spanned;
  18 use rustc_span::symbol::{kw, sym, Ident, Symbol};
  19 use rustc_span::Span;
  20 use rustc_target::spec::abi::Abi;
  21 use std::collections::VecDeque;
  22
  23 pub mod blocks;
  24
  25 fn fn_decl<'hir>(node: Node<'hir>) -> Option<&'hir FnDecl<'hir>> {
  26     match node {
  27         Node::Item(Item { kind: ItemKind::Fn(sig, _, _), .. })
  28         | Node::TraitItem(TraitItem { kind: TraitItemKind::Fn(sig, _), .. })
  29         | Node::ImplItem(ImplItem { kind: ImplItemKind::Fn(sig, _), .. }) => Some(&sig.decl),
  30         Node::Expr(Expr { kind: ExprKind::Closure(_, fn_decl, ..), .. })
  31         | Node::ForeignItem(ForeignItem { kind: ForeignItemKind::Fn(fn_decl, ..), .. }) => {
  32             Some(fn_decl)
  33         }
  34         _ => None,
  35     }
  36 }
  37
  38 pub fn fn_sig<'hir>(node: Node<'hir>) -> Option<&'hir FnSig<'hir>> {
  39     match &node {
  40         Node::Item(Item { kind: ItemKind::Fn(sig, _, _), .. })
  41         | Node::TraitItem(TraitItem { kind: TraitItemKind::Fn(sig, _), .. })
  42         | Node::ImplItem(ImplItem { kind: ImplItemKind::Fn(sig, _), .. }) => Some(sig),
  43         _ => None,
  44     }
  45 }
  46
  47 pub fn associated_body<'hir>(node: Node<'hir>) -> Option<BodyId> {
  48     match node {
  49         Node::Item(Item {
  50             kind: ItemKind::Const(_, body) | ItemKind::Static(.., body) | ItemKind::Fn(.., body),
  51             ..
  52         })
  53         | Node::TraitItem(TraitItem {
  54             kind:
  55                 TraitItemKind::Const(_, Some(body)) | TraitItemKind::Fn(_, TraitFn::Provided(body)),
  56             ..
  57         })
  58         | Node::ImplItem(ImplItem {
  59             kind: ImplItemKind::Const(_, body) | ImplItemKind::Fn(_, body),
  60             ..
  61         })
  62         | Node::Expr(Expr { kind: ExprKind::Closure(.., body, _, _), .. }) => Some(*body),
  63
  64         Node::AnonConst(constant) => Some(constant.body),
  65
  66         _ => None,
  67     }
  68 }
  69
  70 fn is_body_owner<'hir>(node: Node<'hir>, hir_id: HirId) -> bool {
  71     match associated_body(node) {
  72         Some(b) => b.hir_id == hir_id,
  73         None => false,
  74     }
  75 }
  76
  77 #[derive(Copy, Clone)]
  78 pub struct Map<'hir> {
  79     pub(super) tcx: TyCtxt<'hir>,
  80 }
  81
  82 /// An iterator that walks up the ancestor tree of a given `HirId`.
  83 /// Constructed using `tcx.hir().parent_iter(hir_id)`.
  84 pub struct ParentHirIterator<'hir> {
  85     current_id: HirId,
  86     map: Map<'hir>,
  87 }
  88
  89 impl<'hir> Iterator for ParentHirIterator<'hir> {
  90     type Item = (HirId, Node<'hir>);
  91
  92     fn next(&mut self) -> Option<Self::Item> {
  93         if self.current_id == CRATE_HIR_ID {
  94             return None;
  95         }
  96         loop {
  97             // There are nodes that do not have entries, so we need to skip them.
  98             let parent_id = self.map.get_parent_node(self.current_id);
  99
 100             if parent_id == self.current_id {
 101                 self.current_id = CRATE_HIR_ID;
 102                 return None;
 103             }
 104
 105             self.current_id = parent_id;
 106             if let Some(node) = self.map.find(parent_id) {
 107                 return Some((parent_id, node));
 108             }
 109             // If this `HirId` doesn't have an entry, skip it and look for its `parent_id`.
 110         }
 111     }
 112 }
 113
 114 /// An iterator that walks up the ancestor tree of a given `HirId`.
 115 /// Constructed using `tcx.hir().parent_owner_iter(hir_id)`.
 116 pub struct ParentOwnerIterator<'hir> {
 117     current_id: HirId,
 118     map: Map<'hir>,
 119 }
 120
 121 impl<'hir> Iterator for ParentOwnerIterator<'hir> {
 122     type Item = (HirId, OwnerNode<'hir>);
 123
 124     fn next(&mut self) -> Option<Self::Item> {
 125         if self.current_id.local_id.index() != 0 {
 126             self.current_id.local_id = ItemLocalId::new(0);
 127             if let Some(node) = self.map.tcx.hir_owner(self.current_id.owner) {
 128                 return Some((self.current_id, node.node));
 129             }
 130         }
 131         if self.current_id == CRATE_HIR_ID {
 132             return None;
 133         }
 134         loop {
 135             // There are nodes that do not have entries, so we need to skip them.
 136             let parent_id = self.map.def_key(self.current_id.owner).parent;
 137
 138             let parent_id = parent_id.map_or(CRATE_HIR_ID.owner, |local_def_index| {
 139                 let def_id = LocalDefId { local_def_index };
 140                 self.map.local_def_id_to_hir_id(def_id).owner
 141             });
 142             self.current_id = HirId::make_owner(parent_id);
 143
 144             // If this `HirId` doesn't have an entry, skip it and look for its `parent_id`.
 145             if let Some(node) = self.map.tcx.hir_owner(self.current_id.owner) {
 146                 return Some((self.current_id, node.node));
 147             }
 148         }
 149     }
 150 }
 151
 152 impl<'hir> Map<'hir> {
 153     pub fn krate(&self) -> &'hir Crate<'hir> {
 154         self.tcx.hir_crate(())
 155     }
 156
 157     pub fn root_module(&self) -> &'hir Mod<'hir> {
 158         match self.tcx.hir_owner(CRATE_DEF_ID).map(|o| o.node) {
 159             Some(OwnerNode::Crate(item)) => item,
 160             _ => bug!(),
 161         }
 162     }
 163
 164     pub fn items(&self) -> impl Iterator<Item = &'hir Item<'hir>> + 'hir {
 165         let krate = self.krate();
 166         krate.owners.iter().filter_map(|owner| match owner.as_ref()?.node() {
 167             OwnerNode::Item(item) => Some(item),
 168             _ => None,
 169         })
 170     }
 171
 172     pub fn def_key(&self, def_id: LocalDefId) -> DefKey {
 173         // Accessing the DefKey is ok, since it is part of DefPathHash.
 174         self.tcx.untracked_resolutions.definitions.def_key(def_id)
 175     }
 176
 177     pub fn def_path_from_hir_id(&self, id: HirId) -> Option<DefPath> {
 178         self.opt_local_def_id(id).map(|def_id| self.def_path(def_id))
 179     }
 180
 181     pub fn def_path(&self, def_id: LocalDefId) -> DefPath {
 182         // Accessing the DefPath is ok, since it is part of DefPathHash.
 183         self.tcx.untracked_resolutions.definitions.def_path(def_id)
 184     }
 185
 186     #[inline]
 187     pub fn def_path_hash(self, def_id: LocalDefId) -> DefPathHash {
 188         // Accessing the DefPathHash is ok, it is incr. comp. stable.
 189         self.tcx.untracked_resolutions.definitions.def_path_hash(def_id)
 190     }
 191
 192     #[inline]
 193     pub fn local_def_id(&self, hir_id: HirId) -> LocalDefId {
 194         self.opt_local_def_id(hir_id).unwrap_or_else(|| {
 195             bug!(
 196                 "local_def_id: no entry for `{:?}`, which has a map of `{:?}`",
 197                 hir_id,
 198                 self.find(hir_id)
 199             )
 200         })
 201     }
 202
 203     #[inline]
 204     pub fn opt_local_def_id(&self, hir_id: HirId) -> Option<LocalDefId> {
 205         // FIXME(#85914) is this access safe for incr. comp.?
 206         self.tcx.untracked_resolutions.definitions.opt_hir_id_to_local_def_id(hir_id)
 207     }
 208
 209     #[inline]
 210     pub fn local_def_id_to_hir_id(&self, def_id: LocalDefId) -> HirId {
 211         // FIXME(#85914) is this access safe for incr. comp.?
 212         self.tcx.untracked_resolutions.definitions.local_def_id_to_hir_id(def_id)
 213     }
 214
 215     pub fn iter_local_def_id(&self) -> impl Iterator<Item = LocalDefId> + '_ {
 216         // Create a dependency to the crate to be sure we reexcute this when the amount of
 217         // definitions change.
 218         self.tcx.ensure().hir_crate(());
 219         self.tcx.untracked_resolutions.definitions.iter_local_def_id()
 220     }
 221
 222     pub fn opt_def_kind(&self, local_def_id: LocalDefId) -> Option<DefKind> {
 223         let hir_id = self.local_def_id_to_hir_id(local_def_id);
 224         let def_kind = match self.find(hir_id)? {
 225             Node::Item(item) => match item.kind {
 226                 ItemKind::Static(..) => DefKind::Static,
 227                 ItemKind::Const(..) => DefKind::Const,
 228                 ItemKind::Fn(..) => DefKind::Fn,
 229                 ItemKind::Macro(..) => DefKind::Macro(MacroKind::Bang),
 230                 ItemKind::Mod(..) => DefKind::Mod,
 231                 ItemKind::OpaqueTy(..) => DefKind::OpaqueTy,
 232                 ItemKind::TyAlias(..) => DefKind::TyAlias,
 233                 ItemKind::Enum(..) => DefKind::Enum,
 234                 ItemKind::Struct(..) => DefKind::Struct,
 235                 ItemKind::Union(..) => DefKind::Union,
 236                 ItemKind::Trait(..) => DefKind::Trait,
 237                 ItemKind::TraitAlias(..) => DefKind::TraitAlias,
 238                 ItemKind::ExternCrate(_) => DefKind::ExternCrate,
 239                 ItemKind::Use(..) => DefKind::Use,
 240                 ItemKind::ForeignMod { .. } => DefKind::ForeignMod,
 241                 ItemKind::GlobalAsm(..) => DefKind::GlobalAsm,
 242                 ItemKind::Impl { .. } => DefKind::Impl,
 243             },
 244             Node::ForeignItem(item) => match item.kind {
 245                 ForeignItemKind::Fn(..) => DefKind::Fn,
 246                 ForeignItemKind::Static(..) => DefKind::Static,
 247                 ForeignItemKind::Type => DefKind::ForeignTy,
 248             },
 249             Node::TraitItem(item) => match item.kind {
 250                 TraitItemKind::Const(..) => DefKind::AssocConst,
 251                 TraitItemKind::Fn(..) => DefKind::AssocFn,
 252                 TraitItemKind::Type(..) => DefKind::AssocTy,
 253             },
 254             Node::ImplItem(item) => match item.kind {
 255                 ImplItemKind::Const(..) => DefKind::AssocConst,
 256                 ImplItemKind::Fn(..) => DefKind::AssocFn,
 257                 ImplItemKind::TyAlias(..) => DefKind::AssocTy,
 258             },
 259             Node::Variant(_) => DefKind::Variant,
 260             Node::Ctor(variant_data) => {
 261                 // FIXME(eddyb) is this even possible, if we have a `Node::Ctor`?
 262                 assert_ne!(variant_data.ctor_hir_id(), None);
 263
 264                 let ctor_of = match self.find(self.get_parent_node(hir_id)) {
 265                     Some(Node::Item(..)) => def::CtorOf::Struct,
 266                     Some(Node::Variant(..)) => def::CtorOf::Variant,
 267                     _ => unreachable!(),
 268                 };
 269                 DefKind::Ctor(ctor_of, def::CtorKind::from_hir(variant_data))
 270             }
 271             Node::AnonConst(_) => DefKind::AnonConst,
 272             Node::Field(_) => DefKind::Field,
 273             Node::Expr(expr) => match expr.kind {
 274                 ExprKind::Closure(.., None) => DefKind::Closure,
 275                 ExprKind::Closure(.., Some(_)) => DefKind::Generator,
 276                 _ => bug!("def_kind: unsupported node: {}", self.node_to_string(hir_id)),
 277             },
 278             Node::GenericParam(param) => match param.kind {
 279                 GenericParamKind::Lifetime { .. } => DefKind::LifetimeParam,
 280                 GenericParamKind::Type { .. } => DefKind::TyParam,
 281                 GenericParamKind::Const { .. } => DefKind::ConstParam,
 282             },
 283             Node::Crate(_) => DefKind::Mod,
 284             Node::Stmt(_)
 285             | Node::PathSegment(_)
 286             | Node::Ty(_)
 287             | Node::Infer(_)
 288             | Node::TraitRef(_)
 289             | Node::Pat(_)
 290             | Node::Binding(_)
 291             | Node::Local(_)
 292             | Node::Param(_)
 293             | Node::Arm(_)
 294             | Node::Lifetime(_)
 295             | Node::Visibility(_)
 296             | Node::Block(_) => return None,
 297         };
 298         Some(def_kind)
 299     }
 300
 301     pub fn def_kind(&self, local_def_id: LocalDefId) -> DefKind {
 302         self.opt_def_kind(local_def_id)
 303             .unwrap_or_else(|| bug!("def_kind: unsupported node: {:?}", local_def_id))
 304     }
 305
 306     pub fn find_parent_node(&self, id: HirId) -> Option<HirId> {
 307         if id.local_id == ItemLocalId::from_u32(0) {
 308             Some(self.tcx.hir_owner_parent(id.owner))
 309         } else {
 310             let owner = self.tcx.hir_owner_nodes(id.owner)?;
 311             let node = owner.nodes[id.local_id].as_ref()?;
 312             let hir_id = HirId { owner: id.owner, local_id: node.parent };
 313             Some(hir_id)
 314         }
 315     }
 316
 317     pub fn get_parent_node(&self, hir_id: HirId) -> HirId {
 318         self.find_parent_node(hir_id).unwrap()
 319     }
 320
 321     /// Retrieves the `Node` corresponding to `id`, returning `None` if cannot be found.
 322     pub fn find(&self, id: HirId) -> Option<Node<'hir>> {
 323         if id.local_id == ItemLocalId::from_u32(0) {
 324             let owner = self.tcx.hir_owner(id.owner)?;
 325             Some(owner.node.into())
 326         } else {
 327             let owner = self.tcx.hir_owner_nodes(id.owner)?;
 328             let node = owner.nodes[id.local_id].as_ref()?;
 329             Some(node.node)
 330         }
 331     }
 332
 333     /// Retrieves the `Node` corresponding to `id`, panicking if it cannot be found.
 334     pub fn get(&self, id: HirId) -> Node<'hir> {
 335         self.find(id).unwrap_or_else(|| bug!("couldn't find hir id {} in the HIR map", id))
 336     }
 337
 338     pub fn get_if_local(&self, id: DefId) -> Option<Node<'hir>> {
 339         id.as_local().and_then(|id| self.find(self.local_def_id_to_hir_id(id)))
 340     }
 341
 342     pub fn get_generics(&self, id: DefId) -> Option<&'hir Generics<'hir>> {
 343         let id = id.as_local()?;
 344         let node = self.tcx.hir_owner(id)?;
 345         match node.node {
 346             OwnerNode::ImplItem(impl_item) => Some(&impl_item.generics),
 347             OwnerNode::TraitItem(trait_item) => Some(&trait_item.generics),
 348             OwnerNode::Item(Item {
 349                 kind:
 350                     ItemKind::Fn(_, generics, _)
 351                     | ItemKind::TyAlias(_, generics)
 352                     | ItemKind::Enum(_, generics)
 353                     | ItemKind::Struct(_, generics)
 354                     | ItemKind::Union(_, generics)
 355                     | ItemKind::Trait(_, _, generics, ..)
 356                     | ItemKind::TraitAlias(generics, _)
 357                     | ItemKind::Impl(Impl { generics, .. }),
 358                 ..
 359             }) => Some(generics),
 360             _ => None,
 361         }
 362     }
 363
 364     pub fn item(&self, id: ItemId) -> &'hir Item<'hir> {
 365         self.tcx.hir_owner(id.def_id).unwrap().node.expect_item()
 366     }
 367
 368     pub fn trait_item(&self, id: TraitItemId) -> &'hir TraitItem<'hir> {
 369         self.tcx.hir_owner(id.def_id).unwrap().node.expect_trait_item()
 370     }
 371
 372     pub fn impl_item(&self, id: ImplItemId) -> &'hir ImplItem<'hir> {
 373         self.tcx.hir_owner(id.def_id).unwrap().node.expect_impl_item()
 374     }
 375
 376     pub fn foreign_item(&self, id: ForeignItemId) -> &'hir ForeignItem<'hir> {
 377         self.tcx.hir_owner(id.def_id).unwrap().node.expect_foreign_item()
 378     }
 379
 380     pub fn body(&self, id: BodyId) -> &'hir Body<'hir> {
 381         self.tcx.hir_owner_nodes(id.hir_id.owner).unwrap().bodies[id.hir_id.local_id].unwrap()
 382     }
 383
 384     pub fn fn_decl_by_hir_id(&self, hir_id: HirId) -> Option<&'hir FnDecl<'hir>> {
 385         if let Some(node) = self.find(hir_id) {
 386             fn_decl(node)
 387         } else {
 388             bug!("no node for hir_id `{}`", hir_id)
 389         }
 390     }
 391
 392     pub fn fn_sig_by_hir_id(&self, hir_id: HirId) -> Option<&'hir FnSig<'hir>> {
 393         if let Some(node) = self.find(hir_id) {
 394             fn_sig(node)
 395         } else {
 396             bug!("no node for hir_id `{}`", hir_id)
 397         }
 398     }
 399
 400     pub fn enclosing_body_owner(&self, hir_id: HirId) -> HirId {
 401         for (parent, _) in self.parent_iter(hir_id) {
 402             if let Some(body) = self.maybe_body_owned_by(parent) {
 403                 return self.body_owner(body);
 404             }
 405         }
 406
 407         bug!("no `enclosing_body_owner` for hir_id `{}`", hir_id);
 408     }
 409
 410     /// Returns the `HirId` that corresponds to the definition of
 411     /// which this is the body of, i.e., a `fn`, `const` or `static`
 412     /// item (possibly associated), a closure, or a `hir::AnonConst`.
 413     pub fn body_owner(&self, BodyId { hir_id }: BodyId) -> HirId {
 414         let parent = self.get_parent_node(hir_id);
 415         assert!(self.find(parent).map_or(false, |n| is_body_owner(n, hir_id)));
 416         parent
 417     }
 418
 419     pub fn body_owner_def_id(&self, id: BodyId) -> LocalDefId {
 420         self.local_def_id(self.body_owner(id))
 421     }
 422
 423     /// Given a `HirId`, returns the `BodyId` associated with it,
 424     /// if the node is a body owner, otherwise returns `None`.
 425     pub fn maybe_body_owned_by(&self, hir_id: HirId) -> Option<BodyId> {
 426         self.find(hir_id).map(associated_body).flatten()
 427     }
 428
 429     /// Given a body owner's id, returns the `BodyId` associated with it.
 430     pub fn body_owned_by(&self, id: HirId) -> BodyId {
 431         self.maybe_body_owned_by(id).unwrap_or_else(|| {
 432             span_bug!(
 433                 self.span(id),
 434                 "body_owned_by: {} has no associated body",
 435                 self.node_to_string(id)
 436             );
 437         })
 438     }
 439
 440     pub fn body_param_names(&self, id: BodyId) -> impl Iterator<Item = Ident> + 'hir {
 441         self.body(id).params.iter().map(|arg| match arg.pat.kind {
 442             PatKind::Binding(_, _, ident, _) => ident,
 443             _ => Ident::new(kw::Empty, rustc_span::DUMMY_SP),
 444         })
 445     }
 446
 447     /// Returns the `BodyOwnerKind` of this `LocalDefId`.
 448     ///
 449     /// Panics if `LocalDefId` does not have an associated body.
 450     pub fn body_owner_kind(&self, id: HirId) -> BodyOwnerKind {
 451         match self.get(id) {
 452             Node::Item(&Item { kind: ItemKind::Const(..), .. })
 453             | Node::TraitItem(&TraitItem { kind: TraitItemKind::Const(..), .. })
 454             | Node::ImplItem(&ImplItem { kind: ImplItemKind::Const(..), .. })
 455             | Node::AnonConst(_) => BodyOwnerKind::Const,
 456             Node::Ctor(..)
 457             | Node::Item(&Item { kind: ItemKind::Fn(..), .. })
 458             | Node::TraitItem(&TraitItem { kind: TraitItemKind::Fn(..), .. })
 459             | Node::ImplItem(&ImplItem { kind: ImplItemKind::Fn(..), .. }) => BodyOwnerKind::Fn,
 460             Node::Item(&Item { kind: ItemKind::Static(_, m, _), .. }) => BodyOwnerKind::Static(m),
 461             Node::Expr(&Expr { kind: ExprKind::Closure(..), .. }) => BodyOwnerKind::Closure,
 462             node => bug!("{:#?} is not a body node", node),
 463         }
 464     }
 465
 466     /// Returns the `ConstContext` of the body associated with this `LocalDefId`.
 467     ///
 468     /// Panics if `LocalDefId` does not have an associated body.
 469     ///
 470     /// This should only be used for determining the context of a body, a return
 471     /// value of `Some` does not always suggest that the owner of the body is `const`.
 472     pub fn body_const_context(&self, did: LocalDefId) -> Option<ConstContext> {
 473         let hir_id = self.local_def_id_to_hir_id(did);
 474         let ccx = match self.body_owner_kind(hir_id) {
 475             BodyOwnerKind::Const => ConstContext::Const,
 476             BodyOwnerKind::Static(mt) => ConstContext::Static(mt),
 477
 478             BodyOwnerKind::Fn if self.tcx.is_constructor(did.to_def_id()) => return None,
 479             BodyOwnerKind::Fn if self.tcx.is_const_fn_raw(did.to_def_id()) => ConstContext::ConstFn,
 480             BodyOwnerKind::Fn
 481                 if self.tcx.has_attr(did.to_def_id(), sym::default_method_body_is_const) =>
 482             {
 483                 ConstContext::ConstFn
 484             }
 485             BodyOwnerKind::Fn | BodyOwnerKind::Closure => return None,
 486         };
 487
 488         Some(ccx)
 489     }
 490
 491     /// Returns an iterator of the `DefId`s for all body-owners in this
 492     /// crate. If you would prefer to iterate over the bodies
 493     /// themselves, you can do `self.hir().krate().body_ids.iter()`.
 494     pub fn body_owners(self) -> impl Iterator<Item = LocalDefId> + 'hir {
 495         self.krate()
 496             .owners
 497             .iter_enumerated()
 498             .flat_map(move |(owner, owner_info)| {
 499                 let bodies = &owner_info.as_ref()?.nodes.bodies;
 500                 Some(bodies.iter_enumerated().filter_map(move |(local_id, body)| {
 501                     if body.is_none() {
 502                         return None;
 503                     }
 504                     let hir_id = HirId { owner, local_id };
 505                     let body_id = BodyId { hir_id };
 506                     Some(self.body_owner_def_id(body_id))
 507                 }))
 508             })
 509             .flatten()
 510     }
 511
 512     pub fn par_body_owners<F: Fn(LocalDefId) + Sync + Send>(self, f: F) {
 513         use rustc_data_structures::sync::{par_iter, ParallelIterator};
 514         #[cfg(parallel_compiler)]
 515         use rustc_rayon::iter::IndexedParallelIterator;
 516
 517         par_iter(&self.krate().owners.raw).enumerate().for_each(|(owner, owner_info)| {
 518             let owner = LocalDefId::new(owner);
 519             if let Some(owner_info) = owner_info {
 520                 par_iter(&owner_info.nodes.bodies.raw).enumerate().for_each(|(local_id, body)| {
 521                     if body.is_some() {
 522                         let local_id = ItemLocalId::new(local_id);
 523                         let hir_id = HirId { owner, local_id };
 524                         let body_id = BodyId { hir_id };
 525                         f(self.body_owner_def_id(body_id))
 526                     }
 527                 })
 528             }
 529         });
 530     }
 531
 532     pub fn ty_param_owner(&self, id: HirId) -> HirId {
 533         match self.get(id) {
 534             Node::Item(&Item { kind: ItemKind::Trait(..) | ItemKind::TraitAlias(..), .. }) => id,
 535             Node::GenericParam(_) => self.get_parent_node(id),
 536             _ => bug!("ty_param_owner: {} not a type parameter", self.node_to_string(id)),
 537         }
 538     }
 539
 540     pub fn ty_param_name(&self, id: HirId) -> Symbol {
 541         match self.get(id) {
 542             Node::Item(&Item { kind: ItemKind::Trait(..) | ItemKind::TraitAlias(..), .. }) => {
 543                 kw::SelfUpper
 544             }
 545             Node::GenericParam(param) => param.name.ident().name,
 546             _ => bug!("ty_param_name: {} not a type parameter", self.node_to_string(id)),
 547         }
 548     }
 549
 550     pub fn trait_impls(&self, trait_did: DefId) -> &'hir [LocalDefId] {
 551         self.tcx.all_local_trait_impls(()).get(&trait_did).map_or(&[], |xs| &xs[..])
 552     }
 553
 554     /// Gets the attributes on the crate. This is preferable to
 555     /// invoking `krate.attrs` because it registers a tighter
 556     /// dep-graph access.
 557     pub fn krate_attrs(&self) -> &'hir [ast::Attribute] {
 558         self.attrs(CRATE_HIR_ID)
 559     }
 560
 561     pub fn get_module(&self, module: LocalDefId) -> (&'hir Mod<'hir>, Span, HirId) {
 562         let hir_id = HirId::make_owner(module);
 563         match self.tcx.hir_owner(module).map(|o| o.node) {
 564             Some(OwnerNode::Item(&Item { span, kind: ItemKind::Mod(ref m), .. })) => {
 565                 (m, span, hir_id)
 566             }
 567             Some(OwnerNode::Crate(item)) => (item, item.inner, hir_id),
 568             node => panic!("not a module: {:?}", node),
 569         }
 570     }
 571
 572     /// Walks the contents of a crate. See also `Crate::visit_all_items`.
 573     pub fn walk_toplevel_module(self, visitor: &mut impl Visitor<'hir>) {
 574         let (top_mod, span, hir_id) = self.get_module(CRATE_DEF_ID);
 575         visitor.visit_mod(top_mod, span, hir_id);
 576     }
 577
 578     /// Walks the attributes in a crate.
 579     pub fn walk_attributes(self, visitor: &mut impl Visitor<'hir>) {
 580         let krate = self.krate();
 581         for (owner, info) in krate.owners.iter_enumerated() {
 582             if let Some(info) = info {
 583                 for (&local_id, attrs) in info.attrs.map.iter() {
 584                     let id = HirId { owner, local_id };
 585                     for a in *attrs {
 586                         visitor.visit_attribute(id, a)
 587                     }
 588                 }
 589             }
 590         }
 591     }
 592
 593     /// Visits all items in the crate in some deterministic (but
 594     /// unspecified) order. If you just need to process every item,
 595     /// but don't care about nesting, this method is the best choice.
 596     ///
 597     /// If you do care about nesting -- usually because your algorithm
 598     /// follows lexical scoping rules -- then you want a different
 599     /// approach. You should override `visit_nested_item` in your
 600     /// visitor and then call `intravisit::walk_crate` instead.
 601     pub fn visit_all_item_likes<V>(&self, visitor: &mut V)
 602     where
 603         V: itemlikevisit::ItemLikeVisitor<'hir>,
 604     {
 605         let krate = self.krate();
 606         for owner in krate.owners.iter().filter_map(Option::as_ref) {
 607             match owner.node() {
 608                 OwnerNode::Item(item) => visitor.visit_item(item),
 609                 OwnerNode::ForeignItem(item) => visitor.visit_foreign_item(item),
 610                 OwnerNode::ImplItem(item) => visitor.visit_impl_item(item),
 611                 OwnerNode::TraitItem(item) => visitor.visit_trait_item(item),
 612                 OwnerNode::Crate(_) => {}
 613             }
 614         }
 615     }
 616
 617     /// A parallel version of `visit_all_item_likes`.
 618     pub fn par_visit_all_item_likes<V>(&self, visitor: &V)
 619     where
 620         V: itemlikevisit::ParItemLikeVisitor<'hir> + Sync + Send,
 621     {
 622         let krate = self.krate();
 623         par_for_each_in(&krate.owners.raw, |owner| match owner.as_ref().map(OwnerInfo::node) {
 624             Some(OwnerNode::Item(item)) => visitor.visit_item(item),
 625             Some(OwnerNode::ForeignItem(item)) => visitor.visit_foreign_item(item),
 626             Some(OwnerNode::ImplItem(item)) => visitor.visit_impl_item(item),
 627             Some(OwnerNode::TraitItem(item)) => visitor.visit_trait_item(item),
 628             Some(OwnerNode::Crate(_)) | None => {}
 629         })
 630     }
 631
 632     pub fn visit_item_likes_in_module<V>(&self, module: LocalDefId, visitor: &mut V)
 633     where
 634         V: ItemLikeVisitor<'hir>,
 635     {
 636         let module = self.tcx.hir_module_items(module);
 637
 638         for id in module.items.iter() {
 639             visitor.visit_item(self.item(*id));
 640         }
 641
 642         for id in module.trait_items.iter() {
 643             visitor.visit_trait_item(self.trait_item(*id));
 644         }
 645
 646         for id in module.impl_items.iter() {
 647             visitor.visit_impl_item(self.impl_item(*id));
 648         }
 649
 650         for id in module.foreign_items.iter() {
 651             visitor.visit_foreign_item(self.foreign_item(*id));
 652         }
 653     }
 654
 655     pub fn for_each_module(&self, f: impl Fn(LocalDefId)) {
 656         let mut queue = VecDeque::new();
 657         queue.push_back(CRATE_DEF_ID);
 658
 659         while let Some(id) = queue.pop_front() {
 660             f(id);
 661             let items = self.tcx.hir_module_items(id);
 662             queue.extend(items.submodules.iter().copied())
 663         }
 664     }
 665
 666     #[cfg(not(parallel_compiler))]
 667     #[inline]
 668     pub fn par_for_each_module(&self, f: impl Fn(LocalDefId)) {
 669         self.for_each_module(f)
 670     }
 671
 672     #[cfg(parallel_compiler)]
 673     pub fn par_for_each_module(&self, f: impl Fn(LocalDefId) + Sync) {
 674         use rustc_data_structures::sync::{par_iter, ParallelIterator};
 675         par_iter_submodules(self.tcx, CRATE_DEF_ID, &f);
 676
 677         fn par_iter_submodules<F>(tcx: TyCtxt<'_>, module: LocalDefId, f: &F)
 678         where
 679             F: Fn(LocalDefId) + Sync,
 680         {
 681             (*f)(module);
 682             let items = tcx.hir_module_items(module);
 683             par_iter(&items.submodules[..]).for_each(|&sm| par_iter_submodules(tcx, sm, f));
 684         }
 685     }
 686
 687     /// Returns an iterator for the nodes in the ancestor tree of the `current_id`
 688     /// until the crate root is reached. Prefer this over your own loop using `get_parent_node`.
 689     pub fn parent_iter(self, current_id: HirId) -> ParentHirIterator<'hir> {
 690         ParentHirIterator { current_id, map: self }
 691     }
 692
 693     /// Returns an iterator for the nodes in the ancestor tree of the `current_id`
 694     /// until the crate root is reached. Prefer this over your own loop using `get_parent_node`.
 695     pub fn parent_owner_iter(self, current_id: HirId) -> ParentOwnerIterator<'hir> {
 696         ParentOwnerIterator { current_id, map: self }
 697     }
 698
 699     /// Checks if the node is left-hand side of an assignment.
 700     pub fn is_lhs(&self, id: HirId) -> bool {
 701         match self.find(self.get_parent_node(id)) {
 702             Some(Node::Expr(expr)) => match expr.kind {
 703                 ExprKind::Assign(lhs, _rhs, _span) => lhs.hir_id == id,
 704                 _ => false,
 705             },
 706             _ => false,
 707         }
 708     }
 709
 710     /// Whether the expression pointed at by `hir_id` belongs to a `const` evaluation context.
 711     /// Used exclusively for diagnostics, to avoid suggestion function calls.
 712     pub fn is_inside_const_context(&self, hir_id: HirId) -> bool {
 713         self.body_const_context(self.local_def_id(self.enclosing_body_owner(hir_id))).is_some()
 714     }
 715
 716     /// Retrieves the `HirId` for `id`'s enclosing method, unless there's a
 717     /// `while` or `loop` before reaching it, as block tail returns are not
 718     /// available in them.
 719     ///
 720     /// ```
 721     /// fn foo(x: usize) -> bool {
 722     ///     if x == 1 {
 723     ///         true  // If `get_return_block` gets passed the `id` corresponding
 724     ///     } else {  // to this, it will return `foo`'s `HirId`.
 725     ///         false
 726     ///     }
 727     /// }
 728     /// ```
 729     ///
 730     /// ```
 731     /// fn foo(x: usize) -> bool {
 732     ///     loop {
 733     ///         true  // If `get_return_block` gets passed the `id` corresponding
 734     ///     }         // to this, it will return `None`.
 735     ///     false
 736     /// }
 737     /// ```
 738     pub fn get_return_block(&self, id: HirId) -> Option<HirId> {
 739         let mut iter = self.parent_iter(id).peekable();
 740         let mut ignore_tail = false;
 741         if let Some(node) = self.find(id) {
 742             if let Node::Expr(Expr { kind: ExprKind::Ret(_), .. }) = node {
 743                 // When dealing with `return` statements, we don't care about climbing only tail
 744                 // expressions.
 745                 ignore_tail = true;
 746             }
 747         }
 748         while let Some((hir_id, node)) = iter.next() {
 749             if let (Some((_, next_node)), false) = (iter.peek(), ignore_tail) {
 750                 match next_node {
 751                     Node::Block(Block { expr: None, .. }) => return None,
 752                     // The current node is not the tail expression of its parent.
 753                     Node::Block(Block { expr: Some(e), .. }) if hir_id != e.hir_id => return None,
 754                     _ => {}
 755                 }
 756             }
 757             match node {
 758                 Node::Item(_)
 759                 | Node::ForeignItem(_)
 760                 | Node::TraitItem(_)
 761                 | Node::Expr(Expr { kind: ExprKind::Closure(..), .. })
 762                 | Node::ImplItem(_) => return Some(hir_id),
 763                 // Ignore `return`s on the first iteration
 764                 Node::Expr(Expr { kind: ExprKind::Loop(..) | ExprKind::Ret(..), .. })
 765                 | Node::Local(_) => {
 766                     return None;
 767                 }
 768                 _ => {}
 769             }
 770         }
 771         None
 772     }
 773
 774     /// Retrieves the `HirId` for `id`'s parent item, or `id` itself if no
 775     /// parent item is in this map. The "parent item" is the closest parent node
 776     /// in the HIR which is recorded by the map and is an item, either an item
 777     /// in a module, trait, or impl.
 778     pub fn get_parent_item(&self, hir_id: HirId) -> HirId {
 779         if let Some((hir_id, _node)) = self.parent_owner_iter(hir_id).next() {
 780             hir_id
 781         } else {
 782             CRATE_HIR_ID
 783         }
 784     }
 785
 786     /// Returns the `HirId` of `id`'s nearest module parent, or `id` itself if no
 787     /// module parent is in this map.
 788     pub(super) fn get_module_parent_node(&self, hir_id: HirId) -> HirId {
 789         for (hir_id, node) in self.parent_owner_iter(hir_id) {
 790             if let OwnerNode::Item(&Item { kind: ItemKind::Mod(_), .. }) = node {
 791                 return hir_id;
 792             }
 793         }
 794         CRATE_HIR_ID
 795     }
 796
 797     /// When on an if expression, a match arm tail expression or a match arm, give back
 798     /// the enclosing `if` or `match` expression.
 799     ///
 800     /// Used by error reporting when there's a type error in an if or match arm caused by the
 801     /// expression needing to be unit.
 802     pub fn get_if_cause(&self, hir_id: HirId) -> Option<&'hir Expr<'hir>> {
 803         for (_, node) in self.parent_iter(hir_id) {
 804             match node {
 805                 Node::Item(_)
 806                 | Node::ForeignItem(_)
 807                 | Node::TraitItem(_)
 808                 | Node::ImplItem(_)
 809                 | Node::Stmt(Stmt { kind: StmtKind::Local(_), .. }) => break,
 810                 Node::Expr(expr @ Expr { kind: ExprKind::If(..) | ExprKind::Match(..), .. }) => {
 811                     return Some(expr);
 812                 }
 813                 _ => {}
 814             }
 815         }
 816         None
 817     }
 818
 819     /// Returns the nearest enclosing scope. A scope is roughly an item or block.
 820     pub fn get_enclosing_scope(&self, hir_id: HirId) -> Option<HirId> {
 821         for (hir_id, node) in self.parent_iter(hir_id) {
 822             if let Node::Item(Item {
 823                 kind:
 824                     ItemKind::Fn(..)
 825                     | ItemKind::Const(..)
 826                     | ItemKind::Static(..)
 827                     | ItemKind::Mod(..)
 828                     | ItemKind::Enum(..)
 829                     | ItemKind::Struct(..)
 830                     | ItemKind::Union(..)
 831                     | ItemKind::Trait(..)
 832                     | ItemKind::Impl { .. },
 833                 ..
 834             })
 835             | Node::ForeignItem(ForeignItem { kind: ForeignItemKind::Fn(..), .. })
 836             | Node::TraitItem(TraitItem { kind: TraitItemKind::Fn(..), .. })
 837             | Node::ImplItem(ImplItem { kind: ImplItemKind::Fn(..), .. })
 838             | Node::Block(_) = node
 839             {
 840                 return Some(hir_id);
 841             }
 842         }
 843         None
 844     }
 845
 846     /// Returns the defining scope for an opaque type definition.
 847     pub fn get_defining_scope(&self, id: HirId) -> HirId {
 848         let mut scope = id;
 849         loop {
 850             scope = self.get_enclosing_scope(scope).unwrap_or(CRATE_HIR_ID);
 851             if scope == CRATE_HIR_ID || !matches!(self.get(scope), Node::Block(_)) {
 852                 return scope;
 853             }
 854         }
 855     }
 856
 857     pub fn get_parent_did(&self, id: HirId) -> LocalDefId {
 858         self.local_def_id(self.get_parent_item(id))
 859     }
 860
 861     pub fn get_foreign_abi(&self, hir_id: HirId) -> Abi {
 862         let parent = self.get_parent_item(hir_id);
 863         if let Some(node) = self.tcx.hir_owner(self.local_def_id(parent)) {
 864             if let OwnerNode::Item(Item { kind: ItemKind::ForeignMod { abi, .. }, .. }) = node.node
 865             {
 866                 return *abi;
 867             }
 868         }
 869         bug!("expected foreign mod or inlined parent, found {}", self.node_to_string(parent))
 870     }
 871
 872     pub fn expect_item(&self, id: HirId) -> &'hir Item<'hir> {
 873         match self.tcx.hir_owner(id.expect_owner()) {
 874             Some(Owner { node: OwnerNode::Item(item), .. }) => item,
 875             _ => bug!("expected item, found {}", self.node_to_string(id)),
 876         }
 877     }
 878
 879     pub fn expect_impl_item(&self, id: HirId) -> &'hir ImplItem<'hir> {
 880         match self.tcx.hir_owner(id.expect_owner()) {
 881             Some(Owner { node: OwnerNode::ImplItem(item), .. }) => item,
 882             _ => bug!("expected impl item, found {}", self.node_to_string(id)),
 883         }
 884     }
 885
 886     pub fn expect_trait_item(&self, id: HirId) -> &'hir TraitItem<'hir> {
 887         match self.tcx.hir_owner(id.expect_owner()) {
 888             Some(Owner { node: OwnerNode::TraitItem(item), .. }) => item,
 889             _ => bug!("expected trait item, found {}", self.node_to_string(id)),
 890         }
 891     }
 892
 893     pub fn expect_variant(&self, id: HirId) -> &'hir Variant<'hir> {
 894         match self.find(id) {
 895             Some(Node::Variant(variant)) => variant,
 896             _ => bug!("expected variant, found {}", self.node_to_string(id)),
 897         }
 898     }
 899
 900     pub fn expect_foreign_item(&self, id: HirId) -> &'hir ForeignItem<'hir> {
 901         match self.tcx.hir_owner(id.expect_owner()) {
 902             Some(Owner { node: OwnerNode::ForeignItem(item), .. }) => item,
 903             _ => bug!("expected foreign item, found {}", self.node_to_string(id)),
 904         }
 905     }
 906
 907     pub fn expect_expr(&self, id: HirId) -> &'hir Expr<'hir> {
 908         match self.find(id) {
 909             Some(Node::Expr(expr)) => expr,
 910             _ => bug!("expected expr, found {}", self.node_to_string(id)),
 911         }
 912     }
 913
 914     pub fn opt_name(&self, id: HirId) -> Option<Symbol> {
 915         Some(match self.get(id) {
 916             Node::Item(i) => i.ident.name,
 917             Node::ForeignItem(fi) => fi.ident.name,
 918             Node::ImplItem(ii) => ii.ident.name,
 919             Node::TraitItem(ti) => ti.ident.name,
 920             Node::Variant(v) => v.ident.name,
 921             Node::Field(f) => f.ident.name,
 922             Node::Lifetime(lt) => lt.name.ident().name,
 923             Node::GenericParam(param) => param.name.ident().name,
 924             Node::Binding(&Pat { kind: PatKind::Binding(_, _, l, _), .. }) => l.name,
 925             Node::Ctor(..) => self.name(self.get_parent_item(id)),
 926             _ => return None,
 927         })
 928     }
 929
 930     pub fn name(&self, id: HirId) -> Symbol {
 931         match self.opt_name(id) {
 932             Some(name) => name,
 933             None => bug!("no name for {}", self.node_to_string(id)),
 934         }
 935     }
 936
 937     /// Given a node ID, gets a list of attributes associated with the AST
 938     /// corresponding to the node-ID.
 939     pub fn attrs(&self, id: HirId) -> &'hir [ast::Attribute] {
 940         self.tcx.hir_attrs(id.owner).get(id.local_id)
 941     }
 942
 943     /// Gets the span of the definition of the specified HIR node.
 944     /// This is used by `tcx.get_span`
 945     pub fn span(&self, hir_id: HirId) -> Span {
 946         self.opt_span(hir_id)
 947             .unwrap_or_else(|| bug!("hir::map::Map::span: id not in map: {:?}", hir_id))
 948     }
 949
 950     pub fn opt_span(&self, hir_id: HirId) -> Option<Span> {
 951         let span = match self.find(hir_id)? {
 952             Node::Param(param) => param.span,
 953             Node::Item(item) => match &item.kind {
 954                 ItemKind::Fn(sig, _, _) => sig.span,
 955                 _ => item.span,
 956             },
 957             Node::ForeignItem(foreign_item) => foreign_item.span,
 958             Node::TraitItem(trait_item) => match &trait_item.kind {
 959                 TraitItemKind::Fn(sig, _) => sig.span,
 960                 _ => trait_item.span,
 961             },
 962             Node::ImplItem(impl_item) => match &impl_item.kind {
 963                 ImplItemKind::Fn(sig, _) => sig.span,
 964                 _ => impl_item.span,
 965             },
 966             Node::Variant(variant) => variant.span,
 967             Node::Field(field) => field.span,
 968             Node::AnonConst(constant) => self.body(constant.body).value.span,
 969             Node::Expr(expr) => expr.span,
 970             Node::Stmt(stmt) => stmt.span,
 971             Node::PathSegment(seg) => seg.ident.span,
 972             Node::Ty(ty) => ty.span,
 973             Node::TraitRef(tr) => tr.path.span,
 974             Node::Binding(pat) => pat.span,
 975             Node::Pat(pat) => pat.span,
 976             Node::Arm(arm) => arm.span,
 977             Node::Block(block) => block.span,
 978             Node::Ctor(..) => match self.find(self.get_parent_node(hir_id))? {
 979                 Node::Item(item) => item.span,
 980                 Node::Variant(variant) => variant.span,
 981                 _ => unreachable!(),
 982             },
 983             Node::Lifetime(lifetime) => lifetime.span,
 984             Node::GenericParam(param) => param.span,
 985             Node::Visibility(&Spanned {
 986                 node: VisibilityKind::Restricted { ref path, .. },
 987                 ..
 988             }) => path.span,
 989             Node::Infer(i) => i.span,
 990             Node::Visibility(v) => bug!("unexpected Visibility {:?}", v),
 991             Node::Local(local) => local.span,
 992             Node::Crate(item) => item.inner,
 993         };
 994         Some(span)
 995     }
 996
 997     /// Like `hir.span()`, but includes the body of function items
 998     /// (instead of just the function header)
 999     pub fn span_with_body(&self, hir_id: HirId) -> Span {
1000         match self.find(hir_id) {
1001             Some(Node::TraitItem(item)) => item.span,
1002             Some(Node::ImplItem(impl_item)) => impl_item.span,
1003             Some(Node::Item(item)) => item.span,
1004             Some(_) => self.span(hir_id),
1005             _ => bug!("hir::map::Map::span_with_body: id not in map: {:?}", hir_id),
1006         }
1007     }
1008
1009     pub fn span_if_local(&self, id: DefId) -> Option<Span> {
1010         id.as_local().and_then(|id| self.opt_span(self.local_def_id_to_hir_id(id)))
1011     }
1012
1013     pub fn res_span(&self, res: Res) -> Option<Span> {
1014         match res {
1015             Res::Err => None,
1016             Res::Local(id) => Some(self.span(id)),
1017             res => self.span_if_local(res.opt_def_id()?),
1018         }
1019     }
1020
1021     /// Get a representation of this `id` for debugging purposes.
1022     /// NOTE: Do NOT use this in diagnostics!
1023     pub fn node_to_string(&self, id: HirId) -> String {
1024         hir_id_to_string(self, id)
1025     }
1026
1027     /// Returns the HirId of `N` in `struct Foo<const N: usize = { ... }>` when
1028     /// called with the HirId for the `{ ... }` anon const
1029     pub fn opt_const_param_default_param_hir_id(&self, anon_const: HirId) -> Option<HirId> {
1030         match self.get(self.get_parent_node(anon_const)) {
1031             Node::GenericParam(GenericParam {
1032                 hir_id: param_id,
1033                 kind: GenericParamKind::Const { .. },
1034                 ..
1035             }) => Some(*param_id),
1036             _ => None,
1037         }
1038     }
1039 }
1040
1041 impl<'hir> intravisit::Map<'hir> for Map<'hir> {
1042     fn find(&self, hir_id: HirId) -> Option<Node<'hir>> {
1043         self.find(hir_id)
1044     }
1045
1046     fn body(&self, id: BodyId) -> &'hir Body<'hir> {
1047         self.body(id)
1048     }
1049
1050     fn item(&self, id: ItemId) -> &'hir Item<'hir> {
1051         self.item(id)
1052     }
1053
1054     fn trait_item(&self, id: TraitItemId) -> &'hir TraitItem<'hir> {
1055         self.trait_item(id)
1056     }
1057
1058     fn impl_item(&self, id: ImplItemId) -> &'hir ImplItem<'hir> {
1059         self.impl_item(id)
1060     }
1061
1062     fn foreign_item(&self, id: ForeignItemId) -> &'hir ForeignItem<'hir> {
1063         self.foreign_item(id)
1064     }
1065 }
1066
1067 pub(super) fn crate_hash(tcx: TyCtxt<'_>, crate_num: CrateNum) -> Svh {
1068     debug_assert_eq!(crate_num, LOCAL_CRATE);
1069     let mut hir_body_nodes: Vec<_> = tcx
1070         .untracked_resolutions
1071         .definitions
1072         .def_path_table()
1073         .all_def_path_hashes_and_def_ids()
1074         .filter_map(|(def_path_hash, local_def_index)| {
1075             let def_id = LocalDefId { local_def_index };
1076             let hash = tcx.hir_crate(()).owners[def_id].as_ref()?.nodes.hash;
1077             Some((def_path_hash, hash, def_id))
1078         })
1079         .collect();
1080     hir_body_nodes.sort_unstable_by_key(|bn| bn.0);
1081
1082     let upstream_crates = upstream_crates(tcx);
1083
1084     // We hash the final, remapped names of all local source files so we
1085     // don't have to include the path prefix remapping commandline args.
1086     // If we included the full mapping in the SVH, we could only have
1087     // reproducible builds by compiling from the same directory. So we just
1088     // hash the result of the mapping instead of the mapping itself.
1089     let mut source_file_names: Vec<_> = tcx
1090         .sess
1091         .source_map()
1092         .files()
1093         .iter()
1094         .filter(|source_file| source_file.cnum == LOCAL_CRATE)
1095         .map(|source_file| source_file.name_hash)
1096         .collect();
1097
1098     source_file_names.sort_unstable();
1099
1100     let mut hcx = tcx.create_stable_hashing_context();
1101     let mut stable_hasher = StableHasher::new();
1102     for (def_path_hash, fingerprint, def_id) in hir_body_nodes.iter() {
1103         def_path_hash.0.hash_stable(&mut hcx, &mut stable_hasher);
1104         fingerprint.hash_stable(&mut hcx, &mut stable_hasher);
1105         tcx.untracked_crate.owners[*def_id]
1106             .as_ref()
1107             .unwrap()
1108             .attrs
1109             .hash_stable(&mut hcx, &mut stable_hasher);
1110         if tcx.sess.opts.debugging_opts.incremental_relative_spans {
1111             let span = tcx.untracked_resolutions.definitions.def_span(*def_id);
1112             debug_assert_eq!(span.parent(), None);
1113             span.hash_stable(&mut hcx, &mut stable_hasher);
1114         }
1115     }
1116     upstream_crates.hash_stable(&mut hcx, &mut stable_hasher);
1117     source_file_names.hash_stable(&mut hcx, &mut stable_hasher);
1118     tcx.sess.opts.dep_tracking_hash(true).hash_stable(&mut hcx, &mut stable_hasher);
1119     tcx.sess.local_stable_crate_id().hash_stable(&mut hcx, &mut stable_hasher);
1120
1121     let crate_hash: Fingerprint = stable_hasher.finish();
1122     Svh::new(crate_hash.to_smaller_hash())
1123 }
1124
1125 fn upstream_crates(tcx: TyCtxt<'_>) -> Vec<(StableCrateId, Svh)> {
1126     let mut upstream_crates: Vec<_> = tcx
1127         .crates(())
1128         .iter()
1129         .map(|&cnum| {
1130             let stable_crate_id = tcx.resolutions(()).cstore.stable_crate_id(cnum);
1131             let hash = tcx.crate_hash(cnum);
1132             (stable_crate_id, hash)
1133         })
1134         .collect();
1135     upstream_crates.sort_unstable_by_key(|&(stable_crate_id, _)| stable_crate_id);
1136     upstream_crates
1137 }
1138
1139 fn hir_id_to_string(map: &Map<'_>, id: HirId) -> String {
1140     let id_str = format!(" (hir_id={})", id);
1141
1142     let path_str = || {
1143         // This functionality is used for debugging, try to use `TyCtxt` to get
1144         // the user-friendly path, otherwise fall back to stringifying `DefPath`.
1145         crate::ty::tls::with_opt(|tcx| {
1146             if let Some(tcx) = tcx {
1147                 let def_id = map.local_def_id(id);
1148                 tcx.def_path_str(def_id.to_def_id())
1149             } else if let Some(path) = map.def_path_from_hir_id(id) {
1150                 path.data.into_iter().map(|elem| elem.to_string()).collect::<Vec<_>>().join("::")
1151             } else {
1152                 String::from("<missing path>")
1153             }
1154         })
1155     };
1156
1157     let span_str = || map.tcx.sess.source_map().span_to_snippet(map.span(id)).unwrap_or_default();
1158     let node_str = |prefix| format!("{} {}{}", prefix, span_str(), id_str);
1159
1160     match map.find(id) {
1161         Some(Node::Item(item)) => {
1162             let item_str = match item.kind {
1163                 ItemKind::ExternCrate(..) => "extern crate",
1164                 ItemKind::Use(..) => "use",
1165                 ItemKind::Static(..) => "static",
1166                 ItemKind::Const(..) => "const",
1167                 ItemKind::Fn(..) => "fn",
1168                 ItemKind::Macro(..) => "macro",
1169                 ItemKind::Mod(..) => "mod",
1170                 ItemKind::ForeignMod { .. } => "foreign mod",
1171                 ItemKind::GlobalAsm(..) => "global asm",
1172                 ItemKind::TyAlias(..) => "ty",
1173                 ItemKind::OpaqueTy(..) => "opaque type",
1174                 ItemKind::Enum(..) => "enum",
1175                 ItemKind::Struct(..) => "struct",
1176                 ItemKind::Union(..) => "union",
1177                 ItemKind::Trait(..) => "trait",
1178                 ItemKind::TraitAlias(..) => "trait alias",
1179                 ItemKind::Impl { .. } => "impl",
1180             };
1181             format!("{} {}{}", item_str, path_str(), id_str)
1182         }
1183         Some(Node::ForeignItem(_)) => format!("foreign item {}{}", path_str(), id_str),
1184         Some(Node::ImplItem(ii)) => match ii.kind {
1185             ImplItemKind::Const(..) => {
1186                 format!("assoc const {} in {}{}", ii.ident, path_str(), id_str)
1187             }
1188             ImplItemKind::Fn(..) => format!("method {} in {}{}", ii.ident, path_str(), id_str),
1189             ImplItemKind::TyAlias(_) => {
1190                 format!("assoc type {} in {}{}", ii.ident, path_str(), id_str)
1191             }
1192         },
1193         Some(Node::TraitItem(ti)) => {
1194             let kind = match ti.kind {
1195                 TraitItemKind::Const(..) => "assoc constant",
1196                 TraitItemKind::Fn(..) => "trait method",
1197                 TraitItemKind::Type(..) => "assoc type",
1198             };
1199
1200             format!("{} {} in {}{}", kind, ti.ident, path_str(), id_str)
1201         }
1202         Some(Node::Variant(ref variant)) => {
1203             format!("variant {} in {}{}", variant.ident, path_str(), id_str)
1204         }
1205         Some(Node::Field(ref field)) => {
1206             format!("field {} in {}{}", field.ident, path_str(), id_str)
1207         }
1208         Some(Node::AnonConst(_)) => node_str("const"),
1209         Some(Node::Expr(_)) => node_str("expr"),
1210         Some(Node::Stmt(_)) => node_str("stmt"),
1211         Some(Node::PathSegment(_)) => node_str("path segment"),
1212         Some(Node::Ty(_)) => node_str("type"),
1213         Some(Node::TraitRef(_)) => node_str("trait ref"),
1214         Some(Node::Binding(_)) => node_str("local"),
1215         Some(Node::Pat(_)) => node_str("pat"),
1216         Some(Node::Param(_)) => node_str("param"),
1217         Some(Node::Arm(_)) => node_str("arm"),
1218         Some(Node::Block(_)) => node_str("block"),
1219         Some(Node::Infer(_)) => node_str("infer"),
1220         Some(Node::Local(_)) => node_str("local"),
1221         Some(Node::Ctor(..)) => format!("ctor {}{}", path_str(), id_str),
1222         Some(Node::Lifetime(_)) => node_str("lifetime"),
1223         Some(Node::GenericParam(ref param)) => format!("generic_param {:?}{}", param, id_str),
1224         Some(Node::Visibility(ref vis)) => format!("visibility {:?}{}", vis, id_str),
1225         Some(Node::Crate(..)) => String::from("root_crate"),
1226         None => format!("unknown node{}", id_str),
1227     }
1228 }
1229
1230 pub(super) fn hir_module_items(tcx: TyCtxt<'_>, module_id: LocalDefId) -> ModuleItems {
1231     let mut collector = ModuleCollector {
1232         tcx,
1233         submodules: Vec::default(),
1234         items: Vec::default(),
1235         trait_items: Vec::default(),
1236         impl_items: Vec::default(),
1237         foreign_items: Vec::default(),
1238     };
1239
1240     let (hir_mod, span, hir_id) = tcx.hir().get_module(module_id);
1241     collector.visit_mod(hir_mod, span, hir_id);
1242
1243     let ModuleCollector { submodules, items, trait_items, impl_items, foreign_items, .. } =
1244         collector;
1245     return ModuleItems {
1246         submodules: submodules.into_boxed_slice(),
1247         items: items.into_boxed_slice(),
1248         trait_items: trait_items.into_boxed_slice(),
1249         impl_items: impl_items.into_boxed_slice(),
1250         foreign_items: foreign_items.into_boxed_slice(),
1251     };
1252
1253     struct ModuleCollector<'tcx> {
1254         tcx: TyCtxt<'tcx>,
1255         submodules: Vec<LocalDefId>,
1256         items: Vec<ItemId>,
1257         trait_items: Vec<TraitItemId>,
1258         impl_items: Vec<ImplItemId>,
1259         foreign_items: Vec<ForeignItemId>,
1260     }
1261
1262     impl<'hir> Visitor<'hir> for ModuleCollector<'hir> {
1263         type Map = Map<'hir>;
1264
1265         fn nested_visit_map(&mut self) -> intravisit::NestedVisitorMap<Self::Map> {
1266             intravisit::NestedVisitorMap::All(self.tcx.hir())
1267         }
1268
1269         fn visit_item(&mut self, item: &'hir Item<'hir>) {
1270             self.items.push(item.item_id());
1271             if let ItemKind::Mod(..) = item.kind {
1272                 // If this declares another module, do not recurse inside it.
1273                 self.submodules.push(item.def_id);
1274             } else {
1275                 intravisit::walk_item(self, item)
1276             }
1277         }
1278
1279         fn visit_trait_item(&mut self, item: &'hir TraitItem<'hir>) {
1280             self.trait_items.push(item.trait_item_id());
1281             intravisit::walk_trait_item(self, item)
1282         }
1283
1284         fn visit_impl_item(&mut self, item: &'hir ImplItem<'hir>) {
1285             self.impl_items.push(item.impl_item_id());
1286             intravisit::walk_impl_item(self, item)
1287         }
1288
1289         fn visit_foreign_item(&mut self, item: &'hir ForeignItem<'hir>) {
1290             self.foreign_items.push(item.foreign_item_id());
1291             intravisit::walk_foreign_item(self, item)
1292         }
1293     }
1294 }