compiler/rustc_passes/src/hir_id_validator.rs

   1 use rustc_data_structures::sync::Lock;
   2 use rustc_hir as hir;
   3 use rustc_hir::intravisit;
   4 use rustc_hir::{HirId, ItemLocalId};
   5 use rustc_index::bit_set::GrowableBitSet;
   6 use rustc_middle::hir::map::Map;
   7 use rustc_middle::hir::nested_filter;
   8 use rustc_middle::ty::TyCtxt;
   9
  10 pub fn check_crate(tcx: TyCtxt<'_>) {
  11     tcx.dep_graph.assert_ignored();
  12
  13     if tcx.sess.opts.unstable_opts.hir_stats {
  14         crate::hir_stats::print_hir_stats(tcx);
  15     }
  16
  17     #[cfg(debug_assertions)]
  18     {
  19         let errors = Lock::new(Vec::new());
  20         let hir_map = tcx.hir();
  21
  22         hir_map.par_for_each_module(|module_id| {
  23             let mut v = HirIdValidator {
  24                 hir_map,
  25                 owner: None,
  26                 hir_ids_seen: Default::default(),
  27                 errors: &errors,
  28             };
  29
  30             tcx.hir().visit_item_likes_in_module(module_id, &mut v);
  31         });
  32
  33         let errors = errors.into_inner();
  34
  35         if !errors.is_empty() {
  36             let message = errors.iter().fold(String::new(), |s1, s2| s1 + "\n" + s2);
  37             tcx.sess.delay_span_bug(rustc_span::DUMMY_SP, &message);
  38         }
  39     }
  40 }
  41
  42 struct HirIdValidator<'a, 'hir> {
  43     hir_map: Map<'hir>,
  44     owner: Option<hir::OwnerId>,
  45     hir_ids_seen: GrowableBitSet<ItemLocalId>,
  46     errors: &'a Lock<Vec<String>>,
  47 }
  48
  49 impl<'a, 'hir> HirIdValidator<'a, 'hir> {
  50     fn new_visitor(&self, hir_map: Map<'hir>) -> HirIdValidator<'a, 'hir> {
  51         HirIdValidator {
  52             hir_map,
  53             owner: None,
  54             hir_ids_seen: Default::default(),
  55             errors: self.errors,
  56         }
  57     }
  58
  59     #[cold]
  60     #[inline(never)]
  61     fn error(&self, f: impl FnOnce() -> String) {
  62         self.errors.lock().push(f());
  63     }
  64
  65     fn check<F: FnOnce(&mut HirIdValidator<'a, 'hir>)>(&mut self, owner: hir::OwnerId, walk: F) {
  66         assert!(self.owner.is_none());
  67         self.owner = Some(owner);
  68         walk(self);
  69
  70         if owner == hir::CRATE_OWNER_ID {
  71             return;
  72         }
  73
  74         // There's always at least one entry for the owning item itself
  75         let max = self
  76             .hir_ids_seen
  77             .iter()
  78             .map(|local_id| local_id.as_usize())
  79             .max()
  80             .expect("owning item has no entry");
  81
  82         if max != self.hir_ids_seen.len() - 1 {
  83             // Collect the missing ItemLocalIds
  84             let missing: Vec<_> = (0..=max as u32)
  85                 .filter(|&i| !self.hir_ids_seen.contains(ItemLocalId::from_u32(i)))
  86                 .collect();
  87
  88             // Try to map those to something more useful
  89             let mut missing_items = Vec::with_capacity(missing.len());
  90
  91             for local_id in missing {
  92                 let hir_id = HirId { owner, local_id: ItemLocalId::from_u32(local_id) };
  93
  94                 trace!("missing hir id {:#?}", hir_id);
  95
  96                 missing_items.push(format!(
  97                     "[local_id: {}, owner: {}]",
  98                     local_id,
  99                     self.hir_map.def_path(owner.def_id).to_string_no_crate_verbose()
 100                 ));
 101             }
 102             self.error(|| {
 103                 format!(
 104                     "ItemLocalIds not assigned densely in {}. \
 105                 Max ItemLocalId = {}, missing IDs = {:#?}; seens IDs = {:#?}",
 106                     self.hir_map.def_path(owner.def_id).to_string_no_crate_verbose(),
 107                     max,
 108                     missing_items,
 109                     self.hir_ids_seen
 110                         .iter()
 111                         .map(|local_id| HirId { owner, local_id })
 112                         .map(|h| format!("({:?} {})", h, self.hir_map.node_to_string(h)))
 113                         .collect::<Vec<_>>()
 114                 )
 115             });
 116         }
 117     }
 118 }
 119
 120 impl<'a, 'hir> intravisit::Visitor<'hir> for HirIdValidator<'a, 'hir> {
 121     type NestedFilter = nested_filter::OnlyBodies;
 122
 123     fn nested_visit_map(&mut self) -> Self::Map {
 124         self.hir_map
 125     }
 126
 127     fn visit_item(&mut self, i: &'hir hir::Item<'hir>) {
 128         let mut inner_visitor = self.new_visitor(self.hir_map);
 129         inner_visitor.check(i.owner_id, |this| intravisit::walk_item(this, i));
 130     }
 131
 132     fn visit_id(&mut self, hir_id: HirId) {
 133         let owner = self.owner.expect("no owner");
 134
 135         if owner != hir_id.owner {
 136             self.error(|| {
 137                 format!(
 138                     "HirIdValidator: The recorded owner of {} is {} instead of {}",
 139                     self.hir_map.node_to_string(hir_id),
 140                     self.hir_map.def_path(hir_id.owner.def_id).to_string_no_crate_verbose(),
 141                     self.hir_map.def_path(owner.def_id).to_string_no_crate_verbose()
 142                 )
 143             });
 144         }
 145
 146         self.hir_ids_seen.insert(hir_id.local_id);
 147     }
 148
 149     fn visit_foreign_item(&mut self, i: &'hir hir::ForeignItem<'hir>) {
 150         let mut inner_visitor = self.new_visitor(self.hir_map);
 151         inner_visitor.check(i.owner_id, |this| intravisit::walk_foreign_item(this, i));
 152     }
 153
 154     fn visit_trait_item(&mut self, i: &'hir hir::TraitItem<'hir>) {
 155         let mut inner_visitor = self.new_visitor(self.hir_map);
 156         inner_visitor.check(i.owner_id, |this| intravisit::walk_trait_item(this, i));
 157     }
 158
 159     fn visit_impl_item(&mut self, i: &'hir hir::ImplItem<'hir>) {
 160         let mut inner_visitor = self.new_visitor(self.hir_map);
 161         inner_visitor.check(i.owner_id, |this| intravisit::walk_impl_item(this, i));
 162     }
 163 }