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