compiler/rustc_passes/src/hir_id_validator.rs

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