src/librustc/hir/map/hir_id_validator.rs

   1 use crate::hir::def_id::{DefId, DefIndex, CRATE_DEF_INDEX};
   2 use crate::hir::{self, intravisit, HirId, ItemLocalId};
   3 use crate::hir::itemlikevisit::ItemLikeVisitor;
   4 use rustc_data_structures::fx::FxHashSet;
   5 use rustc_data_structures::sync::{Lock, ParallelIterator, par_iter};
   6
   7 pub fn check_crate<'hir>(hir_map: &hir::map::Map<'hir>) {
   8     hir_map.dep_graph.assert_ignored();
   9
  10     let errors = Lock::new(Vec::new());
  11
  12     par_iter(&hir_map.krate().modules).for_each(|(module_id, _)| {
  13         hir_map.visit_item_likes_in_module(hir_map.local_def_id(*module_id), &mut OuterVisitor {
  14             hir_map,
  15             errors: &errors,
  16         });
  17     });
  18
  19     let errors = errors.into_inner();
  20
  21     if !errors.is_empty() {
  22         let message = errors
  23             .iter()
  24             .fold(String::new(), |s1, s2| s1 + "\n" + s2);
  25         bug!("{}", message);
  26     }
  27 }
  28
  29 struct HirIdValidator<'a, 'hir> {
  30     hir_map: &'a hir::map::Map<'hir>,
  31     owner_def_index: Option<DefIndex>,
  32     hir_ids_seen: FxHashSet<ItemLocalId>,
  33     errors: &'a Lock<Vec<String>>,
  34 }
  35
  36 struct OuterVisitor<'a, 'hir> {
  37     hir_map: &'a hir::map::Map<'hir>,
  38     errors: &'a Lock<Vec<String>>,
  39 }
  40
  41 impl<'a, 'hir> OuterVisitor<'a, 'hir> {
  42     fn new_inner_visitor(&self,
  43                          hir_map: &'a hir::map::Map<'hir>)
  44                          -> HirIdValidator<'a, 'hir> {
  45         HirIdValidator {
  46             hir_map,
  47             owner_def_index: None,
  48             hir_ids_seen: Default::default(),
  49             errors: self.errors,
  50         }
  51     }
  52 }
  53
  54 impl<'a, 'hir> ItemLikeVisitor<'hir> for OuterVisitor<'a, 'hir> {
  55     fn visit_item(&mut self, i: &'hir hir::Item) {
  56         let mut inner_visitor = self.new_inner_visitor(self.hir_map);
  57         inner_visitor.check(i.hir_id, |this| intravisit::walk_item(this, i));
  58     }
  59
  60     fn visit_trait_item(&mut self, i: &'hir hir::TraitItem) {
  61         let mut inner_visitor = self.new_inner_visitor(self.hir_map);
  62         inner_visitor.check(i.hir_id, |this| intravisit::walk_trait_item(this, i));
  63     }
  64
  65     fn visit_impl_item(&mut self, i: &'hir hir::ImplItem) {
  66         let mut inner_visitor = self.new_inner_visitor(self.hir_map);
  67         inner_visitor.check(i.hir_id, |this| intravisit::walk_impl_item(this, i));
  68     }
  69 }
  70
  71 impl<'a, 'hir> HirIdValidator<'a, 'hir> {
  72     #[cold]
  73     #[inline(never)]
  74     fn error(&self, f: impl FnOnce() -> String) {
  75         self.errors.lock().push(f());
  76     }
  77
  78     fn check<F: FnOnce(&mut HirIdValidator<'a, 'hir>)>(&mut self,
  79                                                        hir_id: HirId,
  80                                                        walk: F) {
  81         assert!(self.owner_def_index.is_none());
  82         let owner_def_index = self.hir_map.local_def_id_from_hir_id(hir_id).index;
  83         self.owner_def_index = Some(owner_def_index);
  84         walk(self);
  85
  86         if owner_def_index == CRATE_DEF_INDEX {
  87             return;
  88         }
  89
  90         // There's always at least one entry for the owning item itself
  91         let max = self.hir_ids_seen
  92                       .iter()
  93                       .map(|local_id| local_id.as_usize())
  94                       .max()
  95                       .expect("owning item has no entry");
  96
  97         if max != self.hir_ids_seen.len() - 1 {
  98             // Collect the missing ItemLocalIds
  99             let missing: Vec<_> = (0 ..= max as u32)
 100               .filter(|&i| !self.hir_ids_seen.contains(&ItemLocalId::from_u32(i)))
 101               .collect();
 102
 103             // Try to map those to something more useful
 104             let mut missing_items = Vec::with_capacity(missing.len());
 105
 106             for local_id in missing {
 107                 let hir_id = HirId {
 108                     owner: owner_def_index,
 109                     local_id: ItemLocalId::from_u32(local_id),
 110                 };
 111
 112                 trace!("missing hir id {:#?}", hir_id);
 113
 114                 missing_items.push(format!("[local_id: {}, node:{}]",
 115                                            local_id,
 116                                            self.hir_map.node_to_string(hir_id)));
 117             }
 118             self.error(|| format!(
 119                 "ItemLocalIds not assigned densely in {}. \
 120                 Max ItemLocalId = {}, missing IDs = {:?}; seens IDs = {:?}",
 121                 self.hir_map.def_path(DefId::local(owner_def_index)).to_string_no_crate(),
 122                 max,
 123                 missing_items,
 124                 self.hir_ids_seen
 125                     .iter()
 126                     .map(|&local_id| HirId {
 127                         owner: owner_def_index,
 128                         local_id,
 129                     })
 130                     .map(|h| format!("({:?} {})", h, self.hir_map.node_to_string(h)))
 131                     .collect::<Vec<_>>()));
 132         }
 133     }
 134 }
 135
 136 impl<'a, 'hir> intravisit::Visitor<'hir> for HirIdValidator<'a, 'hir> {
 137
 138     fn nested_visit_map<'this>(&'this mut self)
 139                                -> intravisit::NestedVisitorMap<'this, 'hir> {
 140         intravisit::NestedVisitorMap::OnlyBodies(self.hir_map)
 141     }
 142
 143     fn visit_id(&mut self, hir_id: HirId) {
 144         let owner = self.owner_def_index.expect("no owner_def_index");
 145
 146         if hir_id == hir::DUMMY_HIR_ID {
 147             self.error(|| format!("HirIdValidator: HirId {:?} is invalid",
 148                                   self.hir_map.node_to_string(hir_id)));
 149             return;
 150         }
 151
 152         if owner != hir_id.owner {
 153             self.error(|| format!(
 154                 "HirIdValidator: The recorded owner of {} is {} instead of {}",
 155                 self.hir_map.node_to_string(hir_id),
 156                 self.hir_map.def_path(DefId::local(hir_id.owner)).to_string_no_crate(),
 157                 self.hir_map.def_path(DefId::local(owner)).to_string_no_crate()));
 158         }
 159
 160         self.hir_ids_seen.insert(hir_id.local_id);
 161     }
 162
 163     fn visit_impl_item_ref(&mut self, _: &'hir hir::ImplItemRef) {
 164         // Explicitly do nothing here. ImplItemRefs contain hir::Visibility
 165         // values that actually belong to an ImplItem instead of the ItemKind::Impl
 166         // we are currently in. So for those it's correct that they have a
 167         // different owner.
 168     }
 169 }