From 21b0cdc9c0912b953a34d1d2f5fc4b2ff1add8d1 Mon Sep 17 00:00:00 2001 From: Camille GILLOT Date: Sat, 30 Jan 2021 11:28:28 +0100 Subject: [PATCH 01/14] Remove useless Named trait. --- compiler/rustc_middle/src/hir/map/mod.rs | 41 ------------------------ 1 file changed, 41 deletions(-) diff --git a/compiler/rustc_middle/src/hir/map/mod.rs b/compiler/rustc_middle/src/hir/map/mod.rs index 251f8c0afe63d..6a34c9b91df31 100644 --- a/compiler/rustc_middle/src/hir/map/mod.rs +++ b/compiler/rustc_middle/src/hir/map/mod.rs @@ -994,47 +994,6 @@ impl<'hir> intravisit::Map<'hir> for Map<'hir> { } } -trait Named { - fn name(&self) -> Symbol; -} - -impl Named for Spanned { - fn name(&self) -> Symbol { - self.node.name() - } -} - -impl Named for Item<'_> { - fn name(&self) -> Symbol { - self.ident.name - } -} -impl Named for ForeignItem<'_> { - fn name(&self) -> Symbol { - self.ident.name - } -} -impl Named for Variant<'_> { - fn name(&self) -> Symbol { - self.ident.name - } -} -impl Named for StructField<'_> { - fn name(&self) -> Symbol { - self.ident.name - } -} -impl Named for TraitItem<'_> { - fn name(&self) -> Symbol { - self.ident.name - } -} -impl Named for ImplItem<'_> { - fn name(&self) -> Symbol { - self.ident.name - } -} - pub(super) fn index_hir<'tcx>(tcx: TyCtxt<'tcx>, cnum: CrateNum) -> &'tcx IndexedHir<'tcx> { assert_eq!(cnum, LOCAL_CRATE); From ac8961fc047dd33701289f6040e3808fcfb5fb41 Mon Sep 17 00:00:00 2001 From: Camille GILLOT Date: Fri, 29 Jan 2021 19:27:56 +0100 Subject: [PATCH 02/14] Add assertions on HIR enum sizes. --- compiler/rustc_hir/src/hir.rs | 19 +++++++++++++++---- 1 file changed, 15 insertions(+), 4 deletions(-) diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs index 9609510d0af6b..298e3a123cf28 100644 --- a/compiler/rustc_hir/src/hir.rs +++ b/compiler/rustc_hir/src/hir.rs @@ -1413,10 +1413,6 @@ pub struct Expr<'hir> { pub span: Span, } -// `Expr` is used a lot. Make sure it doesn't unintentionally get bigger. -#[cfg(target_arch = "x86_64")] -rustc_data_structures::static_assert_size!(Expr<'static>, 72); - impl Expr<'_> { pub fn precedence(&self) -> ExprPrecedence { match self.kind { @@ -2897,3 +2893,18 @@ impl<'hir> Node<'hir> { } } } + +// Some nodes are used a lot. Make sure they don't unintentionally get bigger. +#[cfg(target_arch = "x86_64")] +mod size_asserts { + rustc_data_structures::static_assert_size!(super::Block<'static>, 48); + rustc_data_structures::static_assert_size!(super::Expr<'static>, 72); + rustc_data_structures::static_assert_size!(super::Pat<'static>, 88); + rustc_data_structures::static_assert_size!(super::QPath<'static>, 24); + rustc_data_structures::static_assert_size!(super::Ty<'static>, 72); + + rustc_data_structures::static_assert_size!(super::Item<'static>, 208); + rustc_data_structures::static_assert_size!(super::TraitItem<'static>, 152); + rustc_data_structures::static_assert_size!(super::ImplItem<'static>, 168); + rustc_data_structures::static_assert_size!(super::ForeignItem<'static>, 160); +} From c676e358a506af3f97025fa248343552bddc57d9 Mon Sep 17 00:00:00 2001 From: Camille GILLOT Date: Sat, 30 Jan 2021 12:06:04 +0100 Subject: [PATCH 03/14] Use ItemId as a strongly typed index. --- compiler/rustc_ast_lowering/src/item.rs | 6 +++--- compiler/rustc_ast_lowering/src/lib.rs | 6 ++++-- compiler/rustc_hir/src/hir.rs | 8 ++++---- compiler/rustc_hir/src/intravisit.rs | 6 +++--- compiler/rustc_hir/src/stable_hash_impls.rs | 9 +++++++++ compiler/rustc_hir_pretty/src/lib.rs | 4 ++-- .../nice_region_error/static_impl_trait.rs | 2 +- compiler/rustc_lint/src/late.rs | 2 +- compiler/rustc_middle/src/hir/map/collector.rs | 2 +- compiler/rustc_middle/src/hir/map/mod.rs | 16 ++++++++-------- compiler/rustc_middle/src/ich/impls_hir.rs | 2 +- compiler/rustc_middle/src/ty/diagnostics.rs | 2 +- .../src/borrow_check/diagnostics/region_name.rs | 2 +- compiler/rustc_passes/src/dead.rs | 2 +- compiler/rustc_passes/src/hir_stats.rs | 2 +- compiler/rustc_privacy/src/lib.rs | 4 ++-- compiler/rustc_resolve/src/late/lifetimes.rs | 5 +++-- compiler/rustc_save_analysis/src/dump_visitor.rs | 2 +- compiler/rustc_save_analysis/src/sig.rs | 2 +- compiler/rustc_typeck/src/astconv/mod.rs | 2 +- .../rustc_typeck/src/check/method/suggest.rs | 4 ++-- src/librustdoc/clean/mod.rs | 6 +++--- src/librustdoc/visit_ast.rs | 8 ++++---- src/tools/clippy/clippy_lints/src/lifetimes.rs | 2 +- .../clippy/clippy_lints/src/manual_async_fn.rs | 2 +- .../clippy/clippy_lints/src/missing_inline.rs | 2 +- .../clippy/clippy_lints/src/utils/author.rs | 2 +- .../clippy/clippy_lints/src/utils/inspector.rs | 2 +- 28 files changed, 63 insertions(+), 51 deletions(-) diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs index 1efe83cacea4a..3b0d0361165a3 100644 --- a/compiler/rustc_ast_lowering/src/item.rs +++ b/compiler/rustc_ast_lowering/src/item.rs @@ -58,8 +58,8 @@ impl<'a> Visitor<'a> for ItemLowerer<'a, '_, '_> { self.lctx.with_hir_id_owner(item.id, |lctx| { lctx.without_in_scope_lifetime_defs(|lctx| { if let Some(hir_item) = lctx.lower_item(item) { - item_hir_id = Some(hir_item.hir_id); - lctx.insert_item(hir_item); + let id = lctx.insert_item(hir_item); + item_hir_id = Some(id); } }) }); @@ -128,7 +128,7 @@ impl<'hir> LoweringContext<'_, 'hir> { // only used when lowering a child item of a trait or impl. fn with_parent_item_lifetime_defs( &mut self, - parent_hir_id: hir::HirId, + parent_hir_id: hir::ItemId, f: impl FnOnce(&mut LoweringContext<'_, '_>) -> T, ) -> T { let old_len = self.in_scope_lifetimes.len(); diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs index f076dca5cf5f1..0f63afa137688 100644 --- a/compiler/rustc_ast_lowering/src/lib.rs +++ b/compiler/rustc_ast_lowering/src/lib.rs @@ -99,7 +99,7 @@ struct LoweringContext<'a, 'hir: 'a> { arena: &'hir Arena<'hir>, /// The items being lowered are collected here. - items: BTreeMap>, + items: BTreeMap>, trait_items: BTreeMap>, impl_items: BTreeMap>, @@ -605,12 +605,14 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { } } - fn insert_item(&mut self, item: hir::Item<'hir>) { + fn insert_item(&mut self, item: hir::Item<'hir>) -> hir::ItemId { let id = item.hir_id; // FIXME: Use `debug_asset-rt`. assert_eq!(id.local_id, hir::ItemLocalId::from_u32(0)); + let id = hir::ItemId { id }; self.items.insert(id, item); self.modules.get_mut(&self.current_module).unwrap().items.insert(id); + id } fn allocate_hir_id_counter(&mut self, owner: NodeId) -> hir::HirId { diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs index 298e3a123cf28..58dd3109b34b5 100644 --- a/compiler/rustc_hir/src/hir.rs +++ b/compiler/rustc_hir/src/hir.rs @@ -619,7 +619,7 @@ pub struct WhereEqPredicate<'hir> { pub struct ModuleItems { // Use BTreeSets here so items are in the same order as in the // list of all items in Crate - pub items: BTreeSet, + pub items: BTreeSet, pub trait_items: BTreeSet, pub impl_items: BTreeSet, pub foreign_items: BTreeSet, @@ -652,7 +652,7 @@ pub struct Crate<'hir> { // does, because it can affect the order in which errors are // detected, which in turn can make UI tests yield // slightly different results. - pub items: BTreeMap>, + pub items: BTreeMap>, pub trait_items: BTreeMap>, pub impl_items: BTreeMap>, @@ -677,7 +677,7 @@ pub struct Crate<'hir> { } impl Crate<'hir> { - pub fn item(&self, id: HirId) -> &Item<'hir> { + pub fn item(&self, id: ItemId) -> &Item<'hir> { &self.items[&id] } @@ -2541,7 +2541,7 @@ impl VariantData<'hir> { // The bodies for items are stored "out of line", in a separate // hashmap in the `Crate`. Here we just record the hir-id of the item // so it can fetched later. -#[derive(Copy, Clone, Encodable, Debug)] +#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Encodable, Debug)] pub struct ItemId { pub id: HirId, } diff --git a/compiler/rustc_hir/src/intravisit.rs b/compiler/rustc_hir/src/intravisit.rs index f8b3f0d9b6e23..70ba81287d0d1 100644 --- a/compiler/rustc_hir/src/intravisit.rs +++ b/compiler/rustc_hir/src/intravisit.rs @@ -133,7 +133,7 @@ pub trait Map<'hir> { /// Retrieves the `Node` corresponding to `id`, returning `None` if cannot be found. fn find(&self, hir_id: HirId) -> Option>; fn body(&self, id: BodyId) -> &'hir Body<'hir>; - fn item(&self, id: HirId) -> &'hir Item<'hir>; + fn item(&self, id: ItemId) -> &'hir Item<'hir>; fn trait_item(&self, id: TraitItemId) -> &'hir TraitItem<'hir>; fn impl_item(&self, id: ImplItemId) -> &'hir ImplItem<'hir>; fn foreign_item(&self, id: ForeignItemId) -> &'hir ForeignItem<'hir>; @@ -150,7 +150,7 @@ impl<'hir> Map<'hir> for ErasedMap<'hir> { fn body(&self, id: BodyId) -> &'hir Body<'hir> { self.0.body(id) } - fn item(&self, id: HirId) -> &'hir Item<'hir> { + fn item(&self, id: ItemId) -> &'hir Item<'hir> { self.0.item(id) } fn trait_item(&self, id: TraitItemId) -> &'hir TraitItem<'hir> { @@ -269,7 +269,7 @@ pub trait Visitor<'v>: Sized { /// reason to override this method is if you want a nested pattern /// but cannot supply a `Map`; see `nested_visit_map` for advice. fn visit_nested_item(&mut self, id: ItemId) { - let opt_item = self.nested_visit_map().inter().map(|map| map.item(id.id)); + let opt_item = self.nested_visit_map().inter().map(|map| map.item(id)); walk_list!(self, visit_item, opt_item); } diff --git a/compiler/rustc_hir/src/stable_hash_impls.rs b/compiler/rustc_hir/src/stable_hash_impls.rs index 439fb88039b40..d8831ec553da5 100644 --- a/compiler/rustc_hir/src/stable_hash_impls.rs +++ b/compiler/rustc_hir/src/stable_hash_impls.rs @@ -34,6 +34,15 @@ impl ToStableHashKey for HirId { } } +impl ToStableHashKey for ItemId { + type KeyType = (DefPathHash, ItemLocalId); + + #[inline] + fn to_stable_hash_key(&self, hcx: &HirCtx) -> (DefPathHash, ItemLocalId) { + self.id.to_stable_hash_key(hcx) + } +} + impl ToStableHashKey for TraitItemId { type KeyType = (DefPathHash, ItemLocalId); diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs index 4595855309fda..e6805b171c579 100644 --- a/compiler/rustc_hir_pretty/src/lib.rs +++ b/compiler/rustc_hir_pretty/src/lib.rs @@ -54,7 +54,7 @@ pub const NO_ANN: &dyn PpAnn = &NoAnn; impl PpAnn for hir::Crate<'_> { fn nested(&self, state: &mut State<'_>, nested: Nested) { match nested { - Nested::Item(id) => state.print_item(self.item(id.id)), + Nested::Item(id) => state.print_item(self.item(id)), Nested::TraitItem(id) => state.print_trait_item(self.trait_item(id)), Nested::ImplItem(id) => state.print_impl_item(self.impl_item(id)), Nested::ForeignItem(id) => state.print_foreign_item(self.foreign_item(id)), @@ -69,7 +69,7 @@ impl PpAnn for hir::Crate<'_> { impl PpAnn for &dyn rustc_hir::intravisit::Map<'_> { fn nested(&self, state: &mut State<'_>, nested: Nested) { match nested { - Nested::Item(id) => state.print_item(self.item(id.id)), + Nested::Item(id) => state.print_item(self.item(id)), Nested::TraitItem(id) => state.print_trait_item(self.trait_item(id)), Nested::ImplItem(id) => state.print_impl_item(self.impl_item(id)), Nested::ForeignItem(id) => state.print_foreign_item(self.foreign_item(id)), diff --git a/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/static_impl_trait.rs b/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/static_impl_trait.rs index c6ae71ba33019..cf669d37dcff9 100644 --- a/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/static_impl_trait.rs +++ b/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/static_impl_trait.rs @@ -234,7 +234,7 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> { } match fn_return.kind { TyKind::OpaqueDef(item_id, _) => { - let item = tcx.hir().item(item_id.id); + let item = tcx.hir().item(item_id); let opaque = if let ItemKind::OpaqueTy(opaque) = &item.kind { opaque } else { diff --git a/compiler/rustc_lint/src/late.rs b/compiler/rustc_lint/src/late.rs index 3821a393efb8b..4cbddc0969d1f 100644 --- a/compiler/rustc_lint/src/late.rs +++ b/compiler/rustc_lint/src/late.rs @@ -178,7 +178,7 @@ impl<'tcx, T: LateLintPass<'tcx>> hir_visit::Visitor<'tcx> for LateContextAndPas } fn visit_stmt(&mut self, s: &'tcx hir::Stmt<'tcx>) { - let get_item = |id: hir::ItemId| self.context.tcx.hir().item(id.id); + let get_item = |id: hir::ItemId| self.context.tcx.hir().item(id); let attrs = &s.kind.attrs(get_item); // See `EarlyContextAndPass::visit_stmt` for an explanation // of why we call `walk_stmt` outside of `with_lint_attrs` diff --git a/compiler/rustc_middle/src/hir/map/collector.rs b/compiler/rustc_middle/src/hir/map/collector.rs index 872fcb0f581d0..358b0deec8c7e 100644 --- a/compiler/rustc_middle/src/hir/map/collector.rs +++ b/compiler/rustc_middle/src/hir/map/collector.rs @@ -309,7 +309,7 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> { fn visit_nested_item(&mut self, item: ItemId) { debug!("visit_nested_item: {:?}", item); - self.visit_item(self.krate.item(item.id)); + self.visit_item(self.krate.item(item)); } fn visit_nested_trait_item(&mut self, item_id: TraitItemId) { diff --git a/compiler/rustc_middle/src/hir/map/mod.rs b/compiler/rustc_middle/src/hir/map/mod.rs index 6a34c9b91df31..f06dc7536765f 100644 --- a/compiler/rustc_middle/src/hir/map/mod.rs +++ b/compiler/rustc_middle/src/hir/map/mod.rs @@ -300,8 +300,8 @@ impl<'hir> Map<'hir> { self.find_entry(id).unwrap() } - pub fn item(&self, id: HirId) -> &'hir Item<'hir> { - match self.find(id).unwrap() { + pub fn item(&self, id: ItemId) -> &'hir Item<'hir> { + match self.find(id.id).unwrap() { Node::Item(item) => item, _ => bug!(), } @@ -479,19 +479,19 @@ impl<'hir> Map<'hir> { let module = self.tcx.hir_module_items(module); for id in &module.items { - visitor.visit_item(self.expect_item(*id)); + visitor.visit_item(self.item(*id)); } for id in &module.trait_items { - visitor.visit_trait_item(self.expect_trait_item(id.hir_id)); + visitor.visit_trait_item(self.trait_item(*id)); } for id in &module.impl_items { - visitor.visit_impl_item(self.expect_impl_item(id.hir_id)); + visitor.visit_impl_item(self.impl_item(*id)); } for id in &module.foreign_items { - visitor.visit_foreign_item(self.expect_foreign_item(id.hir_id)); + visitor.visit_foreign_item(self.foreign_item(*id)); } } @@ -863,7 +863,7 @@ impl<'hir> Map<'hir> { Node::Variant(ref v) => &v.attrs[..], Node::Field(ref f) => &f.attrs[..], Node::Expr(ref e) => &*e.attrs, - Node::Stmt(ref s) => s.kind.attrs(|id| self.item(id.id)), + Node::Stmt(ref s) => s.kind.attrs(|id| self.item(id)), Node::Arm(ref a) => &*a.attrs, Node::GenericParam(param) => ¶m.attrs[..], // Unit/tuple structs/variants take the attributes straight from @@ -977,7 +977,7 @@ impl<'hir> intravisit::Map<'hir> for Map<'hir> { self.body(id) } - fn item(&self, id: HirId) -> &'hir Item<'hir> { + fn item(&self, id: ItemId) -> &'hir Item<'hir> { self.item(id) } diff --git a/compiler/rustc_middle/src/ich/impls_hir.rs b/compiler/rustc_middle/src/ich/impls_hir.rs index d6c6cef17513d..c6291c1c5250d 100644 --- a/compiler/rustc_middle/src/ich/impls_hir.rs +++ b/compiler/rustc_middle/src/ich/impls_hir.rs @@ -55,7 +55,7 @@ impl<'ctx> rustc_hir::HashStableContext for StableHashingContext<'ctx> { let item_ids_hash = item_ids .iter() .map(|id| { - let (def_path_hash, local_id) = id.id.to_stable_hash_key(hcx); + let (def_path_hash, local_id) = id.to_stable_hash_key(hcx); debug_assert_eq!(local_id, hir::ItemLocalId::from_u32(0)); def_path_hash.0 }) diff --git a/compiler/rustc_middle/src/ty/diagnostics.rs b/compiler/rustc_middle/src/ty/diagnostics.rs index 4a131a4ec0581..3b7dc25b6cf50 100644 --- a/compiler/rustc_middle/src/ty/diagnostics.rs +++ b/compiler/rustc_middle/src/ty/diagnostics.rs @@ -289,7 +289,7 @@ impl<'v> hir::intravisit::Visitor<'v> for TraitObjectVisitor<'v> { } hir::TyKind::OpaqueDef(item_id, _) => { self.0.push(ty); - let item = self.1.expect_item(item_id.id); + let item = self.1.item(item_id); hir::intravisit::walk_item(self, item); } _ => {} diff --git a/compiler/rustc_mir/src/borrow_check/diagnostics/region_name.rs b/compiler/rustc_mir/src/borrow_check/diagnostics/region_name.rs index cbca012824f82..63a3e269d6157 100644 --- a/compiler/rustc_mir/src/borrow_check/diagnostics/region_name.rs +++ b/compiler/rustc_mir/src/borrow_check/diagnostics/region_name.rs @@ -767,7 +767,7 @@ impl<'tcx> MirBorrowckCtxt<'_, 'tcx> { let hir = self.infcx.tcx.hir(); if let hir::TyKind::OpaqueDef(id, _) = hir_ty.kind { - let opaque_ty = hir.item(id.id); + let opaque_ty = hir.item(id); if let hir::ItemKind::OpaqueTy(hir::OpaqueTy { bounds: [hir::GenericBound::LangItemTrait( diff --git a/compiler/rustc_passes/src/dead.rs b/compiler/rustc_passes/src/dead.rs index 0d096a0556ba1..a9e843dd176c8 100644 --- a/compiler/rustc_passes/src/dead.rs +++ b/compiler/rustc_passes/src/dead.rs @@ -329,7 +329,7 @@ impl<'tcx> Visitor<'tcx> for MarkSymbolVisitor<'tcx> { fn visit_ty(&mut self, ty: &'tcx hir::Ty<'tcx>) { if let TyKind::OpaqueDef(item_id, _) = ty.kind { - let item = self.tcx.hir().expect_item(item_id.id); + let item = self.tcx.hir().item(item_id); intravisit::walk_item(self, item); } intravisit::walk_ty(self, ty); diff --git a/compiler/rustc_passes/src/hir_stats.rs b/compiler/rustc_passes/src/hir_stats.rs index 1d02c9aa6375d..89acccdde5d73 100644 --- a/compiler/rustc_passes/src/hir_stats.rs +++ b/compiler/rustc_passes/src/hir_stats.rs @@ -100,7 +100,7 @@ impl<'v> hir_visit::Visitor<'v> for StatCollector<'v> { } fn visit_nested_item(&mut self, id: hir::ItemId) { - let nested_item = self.krate.unwrap().item(id.id); + let nested_item = self.krate.unwrap().item(id); self.visit_item(nested_item) } diff --git a/compiler/rustc_privacy/src/lib.rs b/compiler/rustc_privacy/src/lib.rs index 631dcb60594f1..48c4c1c2d5461 100644 --- a/compiler/rustc_privacy/src/lib.rs +++ b/compiler/rustc_privacy/src/lib.rs @@ -588,8 +588,8 @@ impl EmbargoVisitor<'tcx> { .map(|module_hir_id| self.tcx.hir().expect_item(module_hir_id)) { if let hir::ItemKind::Mod(m) = &item.kind { - for item_id in m.item_ids { - let item = self.tcx.hir().expect_item(item_id.id); + for &item_id in m.item_ids { + let item = self.tcx.hir().item(item_id); let def_id = self.tcx.hir().local_def_id(item_id.id); if !self.tcx.hygienic_eq(segment.ident, item.ident, def_id.to_def_id()) { continue; diff --git a/compiler/rustc_resolve/src/late/lifetimes.rs b/compiler/rustc_resolve/src/late/lifetimes.rs index 0bab33976b29d..5f09b643c50c7 100644 --- a/compiler/rustc_resolve/src/late/lifetimes.rs +++ b/compiler/rustc_resolve/src/late/lifetimes.rs @@ -587,7 +587,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> { // `type MyAnonTy<'b> = impl MyTrait<'b>;` // ^ ^ this gets resolved in the scope of // the opaque_ty generics - let opaque_ty = self.tcx.hir().expect_item(item_id.id); + let opaque_ty = self.tcx.hir().item(item_id); let (generics, bounds) = match opaque_ty.kind { // Named opaque `impl Trait` types are reached via `TyKind::Path`. // This arm is for `impl Trait` in the types of statics, constants and locals. @@ -632,11 +632,12 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> { let hir_id = self.tcx.hir().local_def_id_to_hir_id(def_id); // Ensure that the parent of the def is an item, not HRTB let parent_id = self.tcx.hir().get_parent_node(hir_id); + let parent_item_id = hir::ItemId { id: parent_id }; let parent_impl_id = hir::ImplItemId { hir_id: parent_id }; let parent_trait_id = hir::TraitItemId { hir_id: parent_id }; let krate = self.tcx.hir().krate(); - if !(krate.items.contains_key(&parent_id) + if !(krate.items.contains_key(&parent_item_id) || krate.impl_items.contains_key(&parent_impl_id) || krate.trait_items.contains_key(&parent_trait_id)) { diff --git a/compiler/rustc_save_analysis/src/dump_visitor.rs b/compiler/rustc_save_analysis/src/dump_visitor.rs index 2834e7b6322ed..a5360dd313f37 100644 --- a/compiler/rustc_save_analysis/src/dump_visitor.rs +++ b/compiler/rustc_save_analysis/src/dump_visitor.rs @@ -1382,7 +1382,7 @@ impl<'tcx> Visitor<'tcx> for DumpVisitor<'tcx> { }); } hir::TyKind::OpaqueDef(item_id, _) => { - let item = self.tcx.hir().item(item_id.id); + let item = self.tcx.hir().item(item_id); self.nest_typeck_results(self.tcx.hir().local_def_id(item_id.id), |v| { v.visit_item(item) }); diff --git a/compiler/rustc_save_analysis/src/sig.rs b/compiler/rustc_save_analysis/src/sig.rs index 8ada7e34fe844..6540960cc37d1 100644 --- a/compiler/rustc_save_analysis/src/sig.rs +++ b/compiler/rustc_save_analysis/src/sig.rs @@ -317,7 +317,7 @@ impl<'hir> Sig for hir::Ty<'hir> { Ok(replace_text(nested_ty, text)) } hir::TyKind::OpaqueDef(item_id, _) => { - let item = scx.tcx.hir().item(item_id.id); + let item = scx.tcx.hir().item(item_id); item.make(offset, Some(item_id.id), scx) } hir::TyKind::Typeof(_) | hir::TyKind::Infer | hir::TyKind::Err => Err("Ty"), diff --git a/compiler/rustc_typeck/src/astconv/mod.rs b/compiler/rustc_typeck/src/astconv/mod.rs index c9cc47b83e3d6..3dbc71588fe37 100644 --- a/compiler/rustc_typeck/src/astconv/mod.rs +++ b/compiler/rustc_typeck/src/astconv/mod.rs @@ -2210,7 +2210,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o { self.res_to_ty(opt_self_ty, path, false) } hir::TyKind::OpaqueDef(item_id, ref lifetimes) => { - let opaque_ty = tcx.hir().expect_item(item_id.id); + let opaque_ty = tcx.hir().item(item_id); let def_id = tcx.hir().local_def_id(item_id.id).to_def_id(); match opaque_ty.kind { diff --git a/compiler/rustc_typeck/src/check/method/suggest.rs b/compiler/rustc_typeck/src/check/method/suggest.rs index d49c7cae8222b..5c09885b63180 100644 --- a/compiler/rustc_typeck/src/check/method/suggest.rs +++ b/compiler/rustc_typeck/src/check/method/suggest.rs @@ -1445,8 +1445,8 @@ impl intravisit::Visitor<'tcx> for UsePlacementFinder<'tcx> { return; } // Find a `use` statement. - for item_id in module.item_ids { - let item = self.tcx.hir().expect_item(item_id.id); + for &item_id in module.item_ids { + let item = self.tcx.hir().item(item_id); match item.kind { hir::ItemKind::Use(..) => { // Don't suggest placing a `use` before the prelude diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 7e7e417bb6544..e437362a4053e 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -133,7 +133,7 @@ impl Clean for CrateNum { .item_ids .iter() .filter_map(|&id| { - let item = cx.tcx.hir().expect_item(id.id); + let item = cx.tcx.hir().item(id); match item.kind { hir::ItemKind::Mod(_) => as_primitive(Res::Def( DefKind::Mod, @@ -185,7 +185,7 @@ impl Clean for CrateNum { .item_ids .iter() .filter_map(|&id| { - let item = cx.tcx.hir().expect_item(id.id); + let item = cx.tcx.hir().item(id); match item.kind { hir::ItemKind::Mod(_) => as_keyword(Res::Def( DefKind::Mod, @@ -1475,7 +1475,7 @@ impl Clean for hir::Ty<'_> { } TyKind::Tup(ref tys) => Tuple(tys.clean(cx)), TyKind::OpaqueDef(item_id, _) => { - let item = cx.tcx.hir().expect_item(item_id.id); + let item = cx.tcx.hir().item(item_id); if let hir::ItemKind::OpaqueTy(ref ty) = item.kind { ImplTrait(ty.bounds.clean(cx)) } else { diff --git a/src/librustdoc/visit_ast.rs b/src/librustdoc/visit_ast.rs index 7d161ca3648cc..013e27c122940 100644 --- a/src/librustdoc/visit_ast.rs +++ b/src/librustdoc/visit_ast.rs @@ -132,8 +132,8 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> { // Keep track of if there were any private modules in the path. let orig_inside_public_path = self.inside_public_path; self.inside_public_path &= vis.node.is_pub(); - for i in m.item_ids { - let item = self.cx.tcx.hir().expect_item(i.id); + for &i in m.item_ids { + let item = self.cx.tcx.hir().item(i); self.visit_item(item, None, &mut om); } self.inside_public_path = orig_inside_public_path; @@ -231,8 +231,8 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> { let ret = match tcx.hir().get(res_hir_id) { Node::Item(&hir::Item { kind: hir::ItemKind::Mod(ref m), .. }) if glob => { let prev = mem::replace(&mut self.inlining, true); - for i in m.item_ids { - let i = self.cx.tcx.hir().expect_item(i.id); + for &i in m.item_ids { + let i = self.cx.tcx.hir().item(i); self.visit_item(i, None, om); } self.inlining = prev; diff --git a/src/tools/clippy/clippy_lints/src/lifetimes.rs b/src/tools/clippy/clippy_lints/src/lifetimes.rs index e84c8b4e5b3e0..05c747eee0760 100644 --- a/src/tools/clippy/clippy_lints/src/lifetimes.rs +++ b/src/tools/clippy/clippy_lints/src/lifetimes.rs @@ -375,7 +375,7 @@ impl<'a, 'tcx> Visitor<'tcx> for RefVisitor<'a, 'tcx> { match ty.kind { TyKind::OpaqueDef(item, _) => { let map = self.cx.tcx.hir(); - let item = map.expect_item(item.id); + let item = map.item(item); walk_item(self, item); walk_ty(self, ty); }, diff --git a/src/tools/clippy/clippy_lints/src/manual_async_fn.rs b/src/tools/clippy/clippy_lints/src/manual_async_fn.rs index 89f5b2ff31137..2e2e693592c88 100644 --- a/src/tools/clippy/clippy_lints/src/manual_async_fn.rs +++ b/src/tools/clippy/clippy_lints/src/manual_async_fn.rs @@ -102,7 +102,7 @@ fn future_trait_ref<'tcx>( ) -> Option<(&'tcx TraitRef<'tcx>, Vec)> { if_chain! { if let TyKind::OpaqueDef(item_id, bounds) = ty.kind; - let item = cx.tcx.hir().item(item_id.id); + let item = cx.tcx.hir().item(item_id); if let ItemKind::OpaqueTy(opaque) = &item.kind; if let Some(trait_ref) = opaque.bounds.iter().find_map(|bound| { if let GenericBound::Trait(poly, _) = bound { diff --git a/src/tools/clippy/clippy_lints/src/missing_inline.rs b/src/tools/clippy/clippy_lints/src/missing_inline.rs index 913d9daff46fd..1264813d378a3 100644 --- a/src/tools/clippy/clippy_lints/src/missing_inline.rs +++ b/src/tools/clippy/clippy_lints/src/missing_inline.rs @@ -107,7 +107,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingInline { // trait method with default body needs inline in case // an impl is not provided let desc = "a default trait method"; - let item = cx.tcx.hir().expect_trait_item(tit.id.hir_id); + let item = cx.tcx.hir().trait_item(tit.id); check_missing_inline_attrs(cx, &item.attrs, item.span, desc); } }, diff --git a/src/tools/clippy/clippy_lints/src/utils/author.rs b/src/tools/clippy/clippy_lints/src/utils/author.rs index ca60d335262b3..6e3d4fde10777 100644 --- a/src/tools/clippy/clippy_lints/src/utils/author.rs +++ b/src/tools/clippy/clippy_lints/src/utils/author.rs @@ -130,7 +130,7 @@ impl<'tcx> LateLintPass<'tcx> for Author { } fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx hir::Stmt<'_>) { - if !has_attr(cx.sess(), stmt.kind.attrs(|id| cx.tcx.hir().item(id.id))) { + if !has_attr(cx.sess(), stmt.kind.attrs(|id| cx.tcx.hir().item(id))) { return; } prelude(); diff --git a/src/tools/clippy/clippy_lints/src/utils/inspector.rs b/src/tools/clippy/clippy_lints/src/utils/inspector.rs index 9bec24be9e4eb..b52083af6fd34 100644 --- a/src/tools/clippy/clippy_lints/src/utils/inspector.rs +++ b/src/tools/clippy/clippy_lints/src/utils/inspector.rs @@ -109,7 +109,7 @@ impl<'tcx> LateLintPass<'tcx> for DeepCodeInspector { } fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx hir::Stmt<'_>) { - if !has_attr(cx.sess(), stmt.kind.attrs(|id| cx.tcx.hir().item(id.id))) { + if !has_attr(cx.sess(), stmt.kind.attrs(|id| cx.tcx.hir().item(id))) { return; } match stmt.kind { From bd3cd5dbed5f56fb44a14a20dd2113e3049d2565 Mon Sep 17 00:00:00 2001 From: Camille GILLOT Date: Sat, 30 Jan 2021 19:18:48 +0100 Subject: [PATCH 04/14] Use an ItemId inside mir::GlobalAsm. --- .../rustc_codegen_cranelift/src/driver/aot.rs | 4 ++-- .../rustc_codegen_cranelift/src/driver/jit.rs | 7 +++---- compiler/rustc_codegen_ssa/src/mono_item.rs | 4 ++-- compiler/rustc_hir/src/hir.rs | 14 +++++++++++++- compiler/rustc_middle/src/mir/mono.rs | 16 ++++++++-------- compiler/rustc_mir/src/monomorphize/collector.rs | 2 +- .../src/monomorphize/partitioning/default.rs | 6 +++--- 7 files changed, 32 insertions(+), 21 deletions(-) diff --git a/compiler/rustc_codegen_cranelift/src/driver/aot.rs b/compiler/rustc_codegen_cranelift/src/driver/aot.rs index df89883f0bbb7..c9e503a43b9e1 100644 --- a/compiler/rustc_codegen_cranelift/src/driver/aot.rs +++ b/compiler/rustc_codegen_cranelift/src/driver/aot.rs @@ -164,8 +164,8 @@ fn module_codegen(tcx: TyCtxt<'_>, cgu_name: rustc_span::Symbol) -> ModuleCodege MonoItem::Static(def_id) => { crate::constant::codegen_static(&mut cx.constants_cx, def_id) } - MonoItem::GlobalAsm(hir_id) => { - let item = cx.tcx.hir().expect_item(hir_id); + MonoItem::GlobalAsm(item_id) => { + let item = cx.tcx.hir().item(item_id); if let rustc_hir::ItemKind::GlobalAsm(rustc_hir::GlobalAsm { asm }) = item.kind { cx.global_asm.push_str(&*asm.as_str()); cx.global_asm.push_str("\n\n"); diff --git a/compiler/rustc_codegen_cranelift/src/driver/jit.rs b/compiler/rustc_codegen_cranelift/src/driver/jit.rs index 2d14ff2c0221d..f784d8d27cc74 100644 --- a/compiler/rustc_codegen_cranelift/src/driver/jit.rs +++ b/compiler/rustc_codegen_cranelift/src/driver/jit.rs @@ -93,10 +93,9 @@ pub(super) fn run_jit(tcx: TyCtxt<'_>, codegen_mode: CodegenMode) -> ! { MonoItem::Static(def_id) => { crate::constant::codegen_static(&mut cx.constants_cx, def_id); } - MonoItem::GlobalAsm(hir_id) => { - let item = cx.tcx.hir().expect_item(hir_id); - tcx.sess - .span_fatal(item.span, "Global asm is not supported in JIT mode"); + MonoItem::GlobalAsm(item_id) => { + let item = cx.tcx.hir().item(item_id); + tcx.sess.span_fatal(item.span, "Global asm is not supported in JIT mode"); } } } diff --git a/compiler/rustc_codegen_ssa/src/mono_item.rs b/compiler/rustc_codegen_ssa/src/mono_item.rs index 607b5459673f3..8e79193759eb4 100644 --- a/compiler/rustc_codegen_ssa/src/mono_item.rs +++ b/compiler/rustc_codegen_ssa/src/mono_item.rs @@ -30,8 +30,8 @@ impl<'a, 'tcx: 'a> MonoItemExt<'a, 'tcx> for MonoItem<'tcx> { MonoItem::Static(def_id) => { cx.codegen_static(def_id, cx.tcx().is_mutable_static(def_id)); } - MonoItem::GlobalAsm(hir_id) => { - let item = cx.tcx().hir().expect_item(hir_id); + MonoItem::GlobalAsm(item_id) => { + let item = cx.tcx().hir().item(item_id); if let hir::ItemKind::GlobalAsm(ref ga) = item.kind { cx.codegen_global_asm(ga); } else { diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs index 58dd3109b34b5..5329444a5e069 100644 --- a/compiler/rustc_hir/src/hir.rs +++ b/compiler/rustc_hir/src/hir.rs @@ -2541,11 +2541,17 @@ impl VariantData<'hir> { // The bodies for items are stored "out of line", in a separate // hashmap in the `Crate`. Here we just record the hir-id of the item // so it can fetched later. -#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Encodable, Debug)] +#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Encodable, Debug, Hash)] pub struct ItemId { pub id: HirId, } +impl ItemId { + pub fn hir_id(&self) -> HirId { + self.id + } +} + /// An item /// /// The name might be a dummy name in case of anonymous items @@ -2559,6 +2565,12 @@ pub struct Item<'hir> { pub span: Span, } +impl Item<'_> { + pub fn item_id(&self) -> ItemId { + ItemId { id: self.hir_id } + } +} + #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)] #[derive(Encodable, Decodable, HashStable_Generic)] pub enum Unsafety { diff --git a/compiler/rustc_middle/src/mir/mono.rs b/compiler/rustc_middle/src/mir/mono.rs index eb13c89544c13..a4b641ef83a87 100644 --- a/compiler/rustc_middle/src/mir/mono.rs +++ b/compiler/rustc_middle/src/mir/mono.rs @@ -7,7 +7,7 @@ use rustc_data_structures::fingerprint::Fingerprint; use rustc_data_structures::fx::FxHashMap; use rustc_data_structures::stable_hasher::{HashStable, StableHasher}; use rustc_hir::def_id::{CrateNum, DefId, LocalDefId, LOCAL_CRATE}; -use rustc_hir::HirId; +use rustc_hir::{HirId, ItemId}; use rustc_session::config::OptLevel; use rustc_span::source_map::Span; use rustc_span::symbol::Symbol; @@ -43,7 +43,7 @@ pub enum InstantiationMode { pub enum MonoItem<'tcx> { Fn(Instance<'tcx>), Static(DefId), - GlobalAsm(HirId), + GlobalAsm(ItemId), } impl<'tcx> MonoItem<'tcx> { @@ -71,8 +71,8 @@ impl<'tcx> MonoItem<'tcx> { match *self { MonoItem::Fn(instance) => tcx.symbol_name(instance), MonoItem::Static(def_id) => tcx.symbol_name(Instance::mono(tcx, def_id)), - MonoItem::GlobalAsm(hir_id) => { - let def_id = tcx.hir().local_def_id(hir_id); + MonoItem::GlobalAsm(item_id) => { + let def_id = tcx.hir().local_def_id(item_id.hir_id()); SymbolName::new(tcx, &format!("global_asm_{:?}", def_id)) } } @@ -178,7 +178,7 @@ impl<'tcx> MonoItem<'tcx> { MonoItem::Static(def_id) => { def_id.as_local().map(|def_id| tcx.hir().local_def_id_to_hir_id(def_id)) } - MonoItem::GlobalAsm(hir_id) => Some(hir_id), + MonoItem::GlobalAsm(item_id) => Some(item_id.hir_id()), } .map(|hir_id| tcx.hir().span(hir_id)) } @@ -195,9 +195,9 @@ impl<'a, 'tcx> HashStable> for MonoItem<'tcx> { MonoItem::Static(def_id) => { def_id.hash_stable(hcx, hasher); } - MonoItem::GlobalAsm(node_id) => { + MonoItem::GlobalAsm(item_id) => { hcx.with_node_id_hashing_mode(NodeIdHashingMode::HashDefPath, |hcx| { - node_id.hash_stable(hcx, hasher); + item_id.hash_stable(hcx, hasher); }) } } @@ -351,7 +351,7 @@ impl<'tcx> CodegenUnit<'tcx> { MonoItem::Static(def_id) => { def_id.as_local().map(|def_id| tcx.hir().local_def_id_to_hir_id(def_id)) } - MonoItem::GlobalAsm(hir_id) => Some(hir_id), + MonoItem::GlobalAsm(item_id) => Some(item_id.hir_id()), }, item.symbol_name(tcx), ) diff --git a/compiler/rustc_mir/src/monomorphize/collector.rs b/compiler/rustc_mir/src/monomorphize/collector.rs index 75f80f69beafc..1cf809bef450d 100644 --- a/compiler/rustc_mir/src/monomorphize/collector.rs +++ b/compiler/rustc_mir/src/monomorphize/collector.rs @@ -1030,7 +1030,7 @@ impl ItemLikeVisitor<'v> for RootCollector<'_, 'v> { "RootCollector: ItemKind::GlobalAsm({})", self.tcx.def_path_str(self.tcx.hir().local_def_id(item.hir_id).to_def_id()) ); - self.output.push(dummy_spanned(MonoItem::GlobalAsm(item.hir_id))); + self.output.push(dummy_spanned(MonoItem::GlobalAsm(item.item_id()))); } hir::ItemKind::Static(..) => { let def_id = self.tcx.hir().local_def_id(item.hir_id).to_def_id(); diff --git a/compiler/rustc_mir/src/monomorphize/partitioning/default.rs b/compiler/rustc_mir/src/monomorphize/partitioning/default.rs index d5a845dd76fb8..f814da786e5af 100644 --- a/compiler/rustc_mir/src/monomorphize/partitioning/default.rs +++ b/compiler/rustc_mir/src/monomorphize/partitioning/default.rs @@ -314,7 +314,7 @@ fn characteristic_def_id_of_mono_item<'tcx>( Some(def_id) } MonoItem::Static(def_id) => Some(def_id), - MonoItem::GlobalAsm(hir_id) => Some(tcx.hir().local_def_id(hir_id).to_def_id()), + MonoItem::GlobalAsm(item_id) => Some(tcx.hir().local_def_id(item_id.hir_id()).to_def_id()), } } @@ -405,8 +405,8 @@ fn mono_item_visibility( Visibility::Hidden }; } - MonoItem::GlobalAsm(hir_id) => { - let def_id = tcx.hir().local_def_id(*hir_id); + MonoItem::GlobalAsm(item_id) => { + let def_id = tcx.hir().local_def_id(item_id.hir_id()); return if tcx.is_reachable_non_generic(def_id) { *can_be_internalized = false; default_visibility(tcx, def_id.to_def_id(), false) From cebbba081e4609099df3921de8a1422b7ea52599 Mon Sep 17 00:00:00 2001 From: Camille GILLOT Date: Sat, 30 Jan 2021 17:47:51 +0100 Subject: [PATCH 05/14] Only store a LocalDefId in hir::Item. Items are guaranteed to be HIR owner. --- compiler/rustc_ast_lowering/src/item.rs | 17 ++- compiler/rustc_ast_lowering/src/lib.rs | 33 +++-- compiler/rustc_driver/src/pretty.rs | 2 +- compiler/rustc_hir/src/hir.rs | 20 +-- compiler/rustc_hir/src/hir_id.rs | 15 +++ compiler/rustc_hir/src/intravisit.rs | 30 ++--- compiler/rustc_hir/src/stable_hash_impls.rs | 10 +- .../rustc_incremental/src/assert_dep_graph.rs | 2 +- .../src/persist/dirty_clean.rs | 2 +- .../rustc_interface/src/proc_macro_decls.rs | 2 +- compiler/rustc_lint/src/builtin.rs | 45 ++++--- compiler/rustc_lint/src/late.rs | 4 +- compiler/rustc_lint/src/levels.rs | 2 +- compiler/rustc_lint/src/traits.rs | 3 +- compiler/rustc_lint/src/types.rs | 3 +- .../rustc_metadata/src/foreign_modules.rs | 5 +- compiler/rustc_metadata/src/native_libs.rs | 2 +- compiler/rustc_metadata/src/rmeta/encoder.rs | 33 +++-- compiler/rustc_middle/src/hir/map/blocks.rs | 2 +- .../rustc_middle/src/hir/map/collector.rs | 11 +- compiler/rustc_middle/src/hir/map/mod.rs | 2 +- compiler/rustc_middle/src/ich/impls_hir.rs | 3 +- compiler/rustc_middle/src/mir/mono.rs | 3 +- compiler/rustc_middle/src/ty/print/pretty.rs | 8 +- .../rustc_mir/src/monomorphize/collector.rs | 28 ++--- .../src/monomorphize/partitioning/default.rs | 7 +- compiler/rustc_passes/src/check_attr.rs | 2 +- compiler/rustc_passes/src/dead.rs | 16 +-- compiler/rustc_passes/src/diagnostic_items.rs | 2 +- compiler/rustc_passes/src/entry.rs | 11 +- compiler/rustc_passes/src/hir_id_validator.rs | 2 +- compiler/rustc_passes/src/hir_stats.rs | 2 +- compiler/rustc_passes/src/lang_items.rs | 2 +- compiler/rustc_passes/src/layout_test.rs | 6 +- compiler/rustc_passes/src/reachable.rs | 20 +-- compiler/rustc_passes/src/stability.rs | 18 ++- compiler/rustc_plugin_impl/src/build.rs | 10 +- compiler/rustc_privacy/src/lib.rs | 64 +++++----- compiler/rustc_resolve/src/late/lifetimes.rs | 5 +- .../rustc_save_analysis/src/dump_visitor.rs | 117 +++++++----------- compiler/rustc_save_analysis/src/lib.rs | 8 +- compiler/rustc_save_analysis/src/sig.rs | 24 ++-- compiler/rustc_span/src/def_id.rs | 4 + compiler/rustc_symbol_mangling/src/test.rs | 2 +- compiler/rustc_typeck/src/astconv/mod.rs | 2 +- compiler/rustc_typeck/src/check/check.rs | 60 ++++----- .../rustc_typeck/src/check/method/suggest.rs | 11 +- compiler/rustc_typeck/src/check/wfcheck.rs | 53 ++++---- compiler/rustc_typeck/src/check_unused.rs | 39 +++--- .../src/coherence/inherent_impls.rs | 54 ++++---- .../src/coherence/inherent_impls_overlap.rs | 3 +- compiler/rustc_typeck/src/coherence/orphan.rs | 7 +- .../rustc_typeck/src/coherence/unsafety.rs | 3 +- compiler/rustc_typeck/src/collect.rs | 16 +-- compiler/rustc_typeck/src/collect/type_of.rs | 5 +- compiler/rustc_typeck/src/impl_wf_check.rs | 5 +- .../src/outlives/implicit_infer.rs | 9 +- compiler/rustc_typeck/src/outlives/test.rs | 6 +- .../rustc_typeck/src/variance/constraints.rs | 6 +- compiler/rustc_typeck/src/variance/terms.rs | 8 +- compiler/rustc_typeck/src/variance/test.rs | 6 +- src/librustdoc/clean/mod.rs | 40 +++--- src/librustdoc/doctest.rs | 2 +- src/librustdoc/visit_ast.rs | 7 +- .../clippy/clippy_lints/src/copy_iterator.rs | 2 +- src/tools/clippy/clippy_lints/src/derive.rs | 2 +- src/tools/clippy/clippy_lints/src/doc.rs | 7 +- .../clippy/clippy_lints/src/empty_enum.rs | 3 +- .../clippy_lints/src/exhaustive_items.rs | 2 +- .../clippy_lints/src/fallible_impl_from.rs | 3 +- .../clippy/clippy_lints/src/from_over_into.rs | 3 +- .../clippy/clippy_lints/src/functions.rs | 6 +- .../clippy/clippy_lints/src/inherent_impl.rs | 11 +- .../clippy_lints/src/large_enum_variant.rs | 3 +- src/tools/clippy/clippy_lints/src/len_zero.rs | 8 +- .../clippy/clippy_lints/src/methods/mod.rs | 3 +- .../clippy/clippy_lints/src/missing_doc.rs | 6 +- .../clippy/clippy_lints/src/missing_inline.rs | 2 +- src/tools/clippy/clippy_lints/src/mut_key.rs | 2 +- .../clippy_lints/src/needless_borrow.rs | 9 +- src/tools/clippy/clippy_lints/src/ptr.rs | 2 +- .../clippy_lints/src/redundant_pub_crate.rs | 7 +- src/tools/clippy/clippy_lints/src/types.rs | 6 +- src/tools/clippy/clippy_lints/src/use_self.rs | 3 +- .../clippy_lints/src/utils/inspector.rs | 5 +- .../clippy_lints/src/wildcard_imports.rs | 2 +- 86 files changed, 483 insertions(+), 565 deletions(-) diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs index 3b0d0361165a3..8750c2654c5f5 100644 --- a/compiler/rustc_ast_lowering/src/item.rs +++ b/compiler/rustc_ast_lowering/src/item.rs @@ -197,7 +197,9 @@ impl<'hir> LoweringContext<'_, 'hir> { node_ids .into_iter() - .map(|node_id| hir::ItemId { id: self.allocate_hir_id_counter(node_id) }) + .map(|node_id| hir::ItemId { + def_id: self.allocate_hir_id_counter(node_id).expect_owner(), + }) .collect() } @@ -250,7 +252,14 @@ impl<'hir> LoweringContext<'_, 'hir> { let kind = self.lower_item_kind(i.span, i.id, &mut ident, attrs, &mut vis, &i.kind); - Some(hir::Item { hir_id: self.lower_node_id(i.id), ident, attrs, kind, vis, span: i.span }) + Some(hir::Item { + def_id: self.lower_node_id(i.id).expect_owner(), + ident, + attrs, + kind, + vis, + span: i.span, + }) } fn lower_item_kind( @@ -557,7 +566,7 @@ impl<'hir> LoweringContext<'_, 'hir> { let vis = this.rebuild_vis(&vis); this.insert_item(hir::Item { - hir_id: new_id, + def_id: new_id.expect_owner(), ident, attrs, kind, @@ -629,7 +638,7 @@ impl<'hir> LoweringContext<'_, 'hir> { this.lower_use_tree(use_tree, &prefix, id, &mut vis, &mut ident, attrs); this.insert_item(hir::Item { - hir_id: new_hir_id, + def_id: new_hir_id.expect_owner(), ident, attrs, kind, diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs index 0f63afa137688..3cb214464c024 100644 --- a/compiler/rustc_ast_lowering/src/lib.rs +++ b/compiler/rustc_ast_lowering/src/lib.rs @@ -606,10 +606,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { } fn insert_item(&mut self, item: hir::Item<'hir>) -> hir::ItemId { - let id = item.hir_id; - // FIXME: Use `debug_asset-rt`. - assert_eq!(id.local_id, hir::ItemLocalId::from_u32(0)); - let id = hir::ItemId { id }; + let id = hir::ItemId { def_id: item.def_id }; self.items.insert(id, item); self.modules.get_mut(&self.current_module).unwrap().items.insert(id); id @@ -1549,11 +1546,10 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { }; trace!("lower_opaque_impl_trait: {:#?}", opaque_ty_def_id); - let opaque_ty_id = - lctx.generate_opaque_type(opaque_ty_node_id, opaque_ty_item, span, opaque_ty_span); + lctx.generate_opaque_type(opaque_ty_def_id, opaque_ty_item, span, opaque_ty_span); // `impl Trait` now just becomes `Foo<'a, 'b, ..>`. - hir::TyKind::OpaqueDef(hir::ItemId { id: opaque_ty_id }, lifetimes) + hir::TyKind::OpaqueDef(hir::ItemId { def_id: opaque_ty_def_id }, lifetimes) }) } @@ -1561,17 +1557,16 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { /// returns the lowered node-ID for the opaque type. fn generate_opaque_type( &mut self, - opaque_ty_node_id: NodeId, + opaque_ty_id: LocalDefId, opaque_ty_item: hir::OpaqueTy<'hir>, span: Span, opaque_ty_span: Span, - ) -> hir::HirId { + ) { let opaque_ty_item_kind = hir::ItemKind::OpaqueTy(opaque_ty_item); - let opaque_ty_id = self.lower_node_id(opaque_ty_node_id); // Generate an `type Foo = impl Trait;` declaration. trace!("registering opaque type with id {:#?}", opaque_ty_id); let opaque_ty_item = hir::Item { - hir_id: opaque_ty_id, + def_id: opaque_ty_id, ident: Ident::invalid(), attrs: Default::default(), kind: opaque_ty_item_kind, @@ -1583,7 +1578,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { // automatically for all AST items. But this opaque type item // does not actually exist in the AST. self.insert_item(opaque_ty_item); - opaque_ty_id } fn lifetimes_from_impl_trait_bounds( @@ -2012,7 +2006,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { // grow. let input_lifetimes_count = self.in_scope_lifetimes.len() + self.lifetimes_to_define.len(); - let (opaque_ty_id, lifetime_params) = self.with_hir_id_owner(opaque_ty_node_id, |this| { + let lifetime_params = self.with_hir_id_owner(opaque_ty_node_id, |this| { // We have to be careful to get elision right here. The // idea is that we create a lifetime parameter for each // lifetime in the return type. So, given a return type @@ -2063,10 +2057,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { }; trace!("exist ty from async fn def id: {:#?}", opaque_ty_def_id); - let opaque_ty_id = - this.generate_opaque_type(opaque_ty_node_id, opaque_ty_item, span, opaque_ty_span); + this.generate_opaque_type(opaque_ty_def_id, opaque_ty_item, span, opaque_ty_span); - (opaque_ty_id, lifetime_params) + lifetime_params }); // As documented above on the variable @@ -2109,7 +2102,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { // Foo = impl Trait` is, internally, created as a child of the // async fn, so the *type parameters* are inherited. It's // only the lifetime parameters that we must supply. - let opaque_ty_ref = hir::TyKind::OpaqueDef(hir::ItemId { id: opaque_ty_id }, generic_args); + let opaque_ty_ref = + hir::TyKind::OpaqueDef(hir::ItemId { def_id: opaque_ty_def_id }, generic_args); let opaque_ty = self.ty(opaque_ty_span, opaque_ty_ref); hir::FnRetTy::Return(self.arena.alloc(opaque_ty)) } @@ -2434,7 +2428,10 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> { let mut ids: SmallVec<[hir::Stmt<'hir>; 1]> = item_ids .into_iter() .map(|item_id| { - let item_id = hir::ItemId { id: self.lower_node_id(item_id) }; + let item_id = hir::ItemId { + // All the items that `lower_local` finds are `impl Trait` types. + def_id: self.lower_node_id(item_id).expect_owner(), + }; self.stmt(s.span, hir::StmtKind::Item(item_id)) }) .collect(); diff --git a/compiler/rustc_driver/src/pretty.rs b/compiler/rustc_driver/src/pretty.rs index b7edc24bc4a1a..b2e201c5ff2a8 100644 --- a/compiler/rustc_driver/src/pretty.rs +++ b/compiler/rustc_driver/src/pretty.rs @@ -237,7 +237,7 @@ impl<'hir> pprust_hir::PpAnn for IdentifiedAnnotation<'hir> { pprust_hir::AnnNode::Name(_) => {} pprust_hir::AnnNode::Item(item) => { s.s.space(); - s.synth_comment(format!("hir_id: {}", item.hir_id)); + s.synth_comment(format!("hir_id: {}", item.hir_id())); } pprust_hir::AnnNode::SubItem(id) => { s.s.space(); diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs index 5329444a5e069..2abb8fb273125 100644 --- a/compiler/rustc_hir/src/hir.rs +++ b/compiler/rustc_hir/src/hir.rs @@ -2543,12 +2543,13 @@ impl VariantData<'hir> { // so it can fetched later. #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Encodable, Debug, Hash)] pub struct ItemId { - pub id: HirId, + pub def_id: LocalDefId, } impl ItemId { pub fn hir_id(&self) -> HirId { - self.id + // Items are always HIR owners. + HirId::make_owner(self.def_id) } } @@ -2558,7 +2559,7 @@ impl ItemId { #[derive(Debug)] pub struct Item<'hir> { pub ident: Ident, - pub hir_id: HirId, + pub def_id: LocalDefId, pub attrs: &'hir [Attribute], pub kind: ItemKind<'hir>, pub vis: Visibility<'hir>, @@ -2566,8 +2567,13 @@ pub struct Item<'hir> { } impl Item<'_> { + pub fn hir_id(&self) -> HirId { + // Items are always HIR owners. + HirId::make_owner(self.def_id) + } + pub fn item_id(&self) -> ItemId { - ItemId { id: self.hir_id } + ItemId { def_id: self.def_id } } } @@ -2879,8 +2885,8 @@ impl<'hir> Node<'hir> { pub fn hir_id(&self) -> Option { match self { - Node::Item(Item { hir_id, .. }) - | Node::ForeignItem(ForeignItem { hir_id, .. }) + Node::Item(Item { def_id, .. }) => Some(HirId::make_owner(*def_id)), + Node::ForeignItem(ForeignItem { hir_id, .. }) | Node::TraitItem(TraitItem { hir_id, .. }) | Node::ImplItem(ImplItem { hir_id, .. }) | Node::Field(StructField { hir_id, .. }) @@ -2915,7 +2921,7 @@ mod size_asserts { rustc_data_structures::static_assert_size!(super::QPath<'static>, 24); rustc_data_structures::static_assert_size!(super::Ty<'static>, 72); - rustc_data_structures::static_assert_size!(super::Item<'static>, 208); + rustc_data_structures::static_assert_size!(super::Item<'static>, 200); rustc_data_structures::static_assert_size!(super::TraitItem<'static>, 152); rustc_data_structures::static_assert_size!(super::ImplItem<'static>, 168); rustc_data_structures::static_assert_size!(super::ForeignItem<'static>, 160); diff --git a/compiler/rustc_hir/src/hir_id.rs b/compiler/rustc_hir/src/hir_id.rs index cc8ac4cf5be51..dd5cddd8525c1 100644 --- a/compiler/rustc_hir/src/hir_id.rs +++ b/compiler/rustc_hir/src/hir_id.rs @@ -18,6 +18,21 @@ pub struct HirId { pub local_id: ItemLocalId, } +impl HirId { + pub fn expect_owner(self) -> LocalDefId { + assert_eq!(self.local_id.index(), 0); + self.owner + } + + pub fn as_owner(self) -> Option { + if self.local_id.index() == 0 { Some(self.owner) } else { None } + } + + pub fn make_owner(owner: LocalDefId) -> Self { + Self { owner, local_id: ItemLocalId::from_u32(0) } + } +} + impl fmt::Display for HirId { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "{:?}", self) diff --git a/compiler/rustc_hir/src/intravisit.rs b/compiler/rustc_hir/src/intravisit.rs index 70ba81287d0d1..e492cef7733ae 100644 --- a/compiler/rustc_hir/src/intravisit.rs +++ b/compiler/rustc_hir/src/intravisit.rs @@ -565,16 +565,16 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item<'v>) { visitor.visit_ident(item.ident); match item.kind { ItemKind::ExternCrate(orig_name) => { - visitor.visit_id(item.hir_id); + visitor.visit_id(item.hir_id()); if let Some(orig_name) = orig_name { visitor.visit_name(item.span, orig_name); } } ItemKind::Use(ref path, _) => { - visitor.visit_use(path, item.hir_id); + visitor.visit_use(path, item.hir_id()); } ItemKind::Static(ref typ, _, body) | ItemKind::Const(ref typ, body) => { - visitor.visit_id(item.hir_id); + visitor.visit_id(item.hir_id()); visitor.visit_ty(typ); visitor.visit_nested_body(body); } @@ -583,33 +583,33 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item<'v>) { &sig.decl, body_id, item.span, - item.hir_id, + item.hir_id(), ), ItemKind::Mod(ref module) => { // `visit_mod()` takes care of visiting the `Item`'s `HirId`. - visitor.visit_mod(module, item.span, item.hir_id) + visitor.visit_mod(module, item.span, item.hir_id()) } ItemKind::ForeignMod { abi: _, items } => { - visitor.visit_id(item.hir_id); + visitor.visit_id(item.hir_id()); walk_list!(visitor, visit_foreign_item_ref, items); } ItemKind::GlobalAsm(_) => { - visitor.visit_id(item.hir_id); + visitor.visit_id(item.hir_id()); } ItemKind::TyAlias(ref ty, ref generics) => { - visitor.visit_id(item.hir_id); + visitor.visit_id(item.hir_id()); visitor.visit_ty(ty); visitor.visit_generics(generics) } ItemKind::OpaqueTy(OpaqueTy { ref generics, bounds, .. }) => { - visitor.visit_id(item.hir_id); + visitor.visit_id(item.hir_id()); walk_generics(visitor, generics); walk_list!(visitor, visit_param_bound, bounds); } ItemKind::Enum(ref enum_definition, ref generics) => { visitor.visit_generics(generics); // `visit_enum_def()` takes care of visiting the `Item`'s `HirId`. - visitor.visit_enum_def(enum_definition, generics, item.hir_id, item.span) + visitor.visit_enum_def(enum_definition, generics, item.hir_id(), item.span) } ItemKind::Impl(Impl { unsafety: _, @@ -622,7 +622,7 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item<'v>) { ref self_ty, items, }) => { - visitor.visit_id(item.hir_id); + visitor.visit_id(item.hir_id()); visitor.visit_generics(generics); walk_list!(visitor, visit_trait_ref, of_trait); visitor.visit_ty(self_ty); @@ -631,23 +631,23 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item<'v>) { ItemKind::Struct(ref struct_definition, ref generics) | ItemKind::Union(ref struct_definition, ref generics) => { visitor.visit_generics(generics); - visitor.visit_id(item.hir_id); + visitor.visit_id(item.hir_id()); visitor.visit_variant_data( struct_definition, item.ident.name, generics, - item.hir_id, + item.hir_id(), item.span, ); } ItemKind::Trait(.., ref generics, bounds, trait_item_refs) => { - visitor.visit_id(item.hir_id); + visitor.visit_id(item.hir_id()); visitor.visit_generics(generics); walk_list!(visitor, visit_param_bound, bounds); walk_list!(visitor, visit_trait_item_ref, trait_item_refs); } ItemKind::TraitAlias(ref generics, bounds) => { - visitor.visit_id(item.hir_id); + visitor.visit_id(item.hir_id()); visitor.visit_generics(generics); walk_list!(visitor, visit_param_bound, bounds); } diff --git a/compiler/rustc_hir/src/stable_hash_impls.rs b/compiler/rustc_hir/src/stable_hash_impls.rs index d8831ec553da5..b0d332e0028f0 100644 --- a/compiler/rustc_hir/src/stable_hash_impls.rs +++ b/compiler/rustc_hir/src/stable_hash_impls.rs @@ -35,11 +35,11 @@ impl ToStableHashKey for HirId { } impl ToStableHashKey for ItemId { - type KeyType = (DefPathHash, ItemLocalId); + type KeyType = DefPathHash; #[inline] - fn to_stable_hash_key(&self, hcx: &HirCtx) -> (DefPathHash, ItemLocalId) { - self.id.to_stable_hash_key(hcx) + fn to_stable_hash_key(&self, hcx: &HirCtx) -> DefPathHash { + hcx.local_def_path_hash(self.def_id) } } @@ -91,7 +91,7 @@ impl HashStable for BodyId { impl HashStable for ItemId { fn hash_stable(&self, hcx: &mut HirCtx, hasher: &mut StableHasher) { - hcx.hash_reference_to_item(self.id, hasher) + hcx.hash_reference_to_item(self.hir_id(), hasher) } } @@ -178,7 +178,7 @@ impl HashStable for ImplItem<'_> { impl HashStable for Item<'_> { fn hash_stable(&self, hcx: &mut HirCtx, hasher: &mut StableHasher) { - let Item { ident, ref attrs, hir_id: _, ref kind, ref vis, span } = *self; + let Item { ident, ref attrs, def_id: _, ref kind, ref vis, span } = *self; hcx.hash_hir_item_like(|hcx| { ident.name.hash_stable(hcx, hasher); diff --git a/compiler/rustc_incremental/src/assert_dep_graph.rs b/compiler/rustc_incremental/src/assert_dep_graph.rs index f39a92b9a32ba..6c0f0542e0c2c 100644 --- a/compiler/rustc_incremental/src/assert_dep_graph.rs +++ b/compiler/rustc_incremental/src/assert_dep_graph.rs @@ -167,7 +167,7 @@ impl Visitor<'tcx> for IfThisChanged<'tcx> { } fn visit_item(&mut self, item: &'tcx hir::Item<'tcx>) { - self.process_attrs(item.hir_id, &item.attrs); + self.process_attrs(item.hir_id(), &item.attrs); intravisit::walk_item(self, item); } diff --git a/compiler/rustc_incremental/src/persist/dirty_clean.rs b/compiler/rustc_incremental/src/persist/dirty_clean.rs index e1c60050d9435..518ab78ea68b4 100644 --- a/compiler/rustc_incremental/src/persist/dirty_clean.rs +++ b/compiler/rustc_incremental/src/persist/dirty_clean.rs @@ -450,7 +450,7 @@ impl DirtyCleanVisitor<'tcx> { impl ItemLikeVisitor<'tcx> for DirtyCleanVisitor<'tcx> { fn visit_item(&mut self, item: &'tcx hir::Item<'tcx>) { - self.check_item(item.hir_id, item.span); + self.check_item(item.hir_id(), item.span); } fn visit_trait_item(&mut self, item: &hir::TraitItem<'_>) { diff --git a/compiler/rustc_interface/src/proc_macro_decls.rs b/compiler/rustc_interface/src/proc_macro_decls.rs index de08a4c8242fe..d0262935c894c 100644 --- a/compiler/rustc_interface/src/proc_macro_decls.rs +++ b/compiler/rustc_interface/src/proc_macro_decls.rs @@ -26,7 +26,7 @@ struct Finder<'tcx> { impl<'v> ItemLikeVisitor<'v> for Finder<'_> { fn visit_item(&mut self, item: &hir::Item<'_>) { if self.tcx.sess.contains_name(&item.attrs, sym::rustc_proc_macro_decls) { - self.decls = Some(item.hir_id); + self.decls = Some(item.hir_id()); } } diff --git a/compiler/rustc_lint/src/builtin.rs b/compiler/rustc_lint/src/builtin.rs index 20f581625dc31..baab339a3240f 100644 --- a/compiler/rustc_lint/src/builtin.rs +++ b/compiler/rustc_lint/src/builtin.rs @@ -36,9 +36,9 @@ use rustc_feature::{deprecated_attributes, AttributeGate, AttributeTemplate, Att use rustc_feature::{GateIssue, Stability}; use rustc_hir as hir; use rustc_hir::def::{DefKind, Res}; -use rustc_hir::def_id::DefId; +use rustc_hir::def_id::{DefId, LocalDefId, LocalDefIdSet}; use rustc_hir::{ForeignItemKind, GenericParamKind, PatKind}; -use rustc_hir::{HirId, HirIdSet, Node}; +use rustc_hir::{HirId, Node}; use rustc_index::vec::Idx; use rustc_middle::lint::LintDiagnosticBuilder; use rustc_middle::ty::print::with_no_trimmed_paths; @@ -173,8 +173,7 @@ impl<'tcx> LateLintPass<'tcx> for BoxPointers { | hir::ItemKind::Enum(..) | hir::ItemKind::Struct(..) | hir::ItemKind::Union(..) => { - let def_id = cx.tcx.hir().local_def_id(it.hir_id); - self.check_heap_type(cx, it.span, cx.tcx.type_of(def_id)) + self.check_heap_type(cx, it.span, cx.tcx.type_of(it.def_id)) } _ => (), } @@ -585,7 +584,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc { hir::ItemKind::Trait(.., trait_item_refs) => { // Issue #11592: traits are always considered exported, even when private. if let hir::VisibilityKind::Inherited = it.vis.node { - self.private_traits.insert(it.hir_id); + self.private_traits.insert(it.hir_id()); for trait_item_ref in trait_item_refs { self.private_traits.insert(trait_item_ref.id.hir_id); } @@ -621,10 +620,9 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc { _ => return, }; - let def_id = cx.tcx.hir().local_def_id(it.hir_id); - let (article, desc) = cx.tcx.article_and_description(def_id.to_def_id()); + let (article, desc) = cx.tcx.article_and_description(it.def_id.to_def_id()); - self.check_missing_docs_attrs(cx, Some(it.hir_id), &it.attrs, it.span, article, desc); + self.check_missing_docs_attrs(cx, Some(it.hir_id()), &it.attrs, it.span, article, desc); } fn check_trait_item(&mut self, cx: &LateContext<'_>, trait_item: &hir::TraitItem<'_>) { @@ -732,7 +730,7 @@ declare_lint_pass!(MissingCopyImplementations => [MISSING_COPY_IMPLEMENTATIONS]) impl<'tcx> LateLintPass<'tcx> for MissingCopyImplementations { fn check_item(&mut self, cx: &LateContext<'_>, item: &hir::Item<'_>) { - if !cx.access_levels.is_reachable(item.hir_id) { + if !cx.access_levels.is_reachable(item.hir_id()) { return; } let (def, ty) = match item.kind { @@ -740,21 +738,21 @@ impl<'tcx> LateLintPass<'tcx> for MissingCopyImplementations { if !ast_generics.params.is_empty() { return; } - let def = cx.tcx.adt_def(cx.tcx.hir().local_def_id(item.hir_id)); + let def = cx.tcx.adt_def(item.def_id); (def, cx.tcx.mk_adt(def, cx.tcx.intern_substs(&[]))) } hir::ItemKind::Union(_, ref ast_generics) => { if !ast_generics.params.is_empty() { return; } - let def = cx.tcx.adt_def(cx.tcx.hir().local_def_id(item.hir_id)); + let def = cx.tcx.adt_def(item.def_id); (def, cx.tcx.mk_adt(def, cx.tcx.intern_substs(&[]))) } hir::ItemKind::Enum(_, ref ast_generics) => { if !ast_generics.params.is_empty() { return; } - let def = cx.tcx.adt_def(cx.tcx.hir().local_def_id(item.hir_id)); + let def = cx.tcx.adt_def(item.def_id); (def, cx.tcx.mk_adt(def, cx.tcx.intern_substs(&[]))) } _ => return, @@ -812,14 +810,14 @@ declare_lint! { #[derive(Default)] pub struct MissingDebugImplementations { - impling_types: Option, + impling_types: Option, } impl_lint_pass!(MissingDebugImplementations => [MISSING_DEBUG_IMPLEMENTATIONS]); impl<'tcx> LateLintPass<'tcx> for MissingDebugImplementations { fn check_item(&mut self, cx: &LateContext<'_>, item: &hir::Item<'_>) { - if !cx.access_levels.is_reachable(item.hir_id) { + if !cx.access_levels.is_reachable(item.hir_id()) { return; } @@ -834,11 +832,11 @@ impl<'tcx> LateLintPass<'tcx> for MissingDebugImplementations { }; if self.impling_types.is_none() { - let mut impls = HirIdSet::default(); + let mut impls = LocalDefIdSet::default(); cx.tcx.for_each_impl(debug, |d| { if let Some(ty_def) = cx.tcx.type_of(d).ty_adt_def() { if let Some(def_id) = ty_def.did.as_local() { - impls.insert(cx.tcx.hir().local_def_id_to_hir_id(def_id)); + impls.insert(def_id); } } }); @@ -847,7 +845,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingDebugImplementations { debug!("{:?}", self.impling_types); } - if !self.impling_types.as_ref().unwrap().contains(&item.hir_id) { + if !self.impling_types.as_ref().unwrap().contains(&item.def_id) { cx.struct_span_lint(MISSING_DEBUG_IMPLEMENTATIONS, item.span, |lint| { lint.build(&format!( "type does not implement `{}`; consider adding `#[derive(Debug)]` \ @@ -1362,7 +1360,7 @@ impl UnreachablePub { impl<'tcx> LateLintPass<'tcx> for UnreachablePub { fn check_item(&mut self, cx: &LateContext<'_>, item: &hir::Item<'_>) { - self.perform_lint(cx, "item", item.hir_id, &item.vis, item.span, true); + self.perform_lint(cx, "item", item.hir_id(), &item.vis, item.span, true); } fn check_foreign_item(&mut self, cx: &LateContext<'_>, foreign_item: &hir::ForeignItem<'tcx>) { @@ -1603,8 +1601,7 @@ impl<'tcx> LateLintPass<'tcx> for TrivialConstraints { use rustc_middle::ty::PredicateKind::*; if cx.tcx.features().trivial_bounds { - let def_id = cx.tcx.hir().local_def_id(item.hir_id); - let predicates = cx.tcx.predicates_of(def_id); + let predicates = cx.tcx.predicates_of(item.def_id); for &(predicate, span) in predicates.predicates { let predicate_kind_name = match predicate.kind().skip_binder() { Trait(..) => "Trait", @@ -1810,7 +1807,7 @@ declare_lint! { } pub struct UnnameableTestItems { - boundary: Option, // HirId of the item under which things are not nameable + boundary: Option, // Id of the item under which things are not nameable items_nameable: bool, } @@ -1828,7 +1825,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnameableTestItems { if let hir::ItemKind::Mod(..) = it.kind { } else { self.items_nameable = false; - self.boundary = Some(it.hir_id); + self.boundary = Some(it.def_id); } return; } @@ -1841,7 +1838,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnameableTestItems { } fn check_item_post(&mut self, _cx: &LateContext<'_>, it: &hir::Item<'_>) { - if !self.items_nameable && self.boundary == Some(it.hir_id) { + if !self.items_nameable && self.boundary == Some(it.def_id) { self.items_nameable = true; } } @@ -2125,7 +2122,7 @@ impl<'tcx> LateLintPass<'tcx> for ExplicitOutlivesRequirements { use rustc_middle::middle::resolve_lifetime::Region; let infer_static = cx.tcx.features().infer_static_outlives_requirements; - let def_id = cx.tcx.hir().local_def_id(item.hir_id); + let def_id = item.def_id; if let hir::ItemKind::Struct(_, ref hir_generics) | hir::ItemKind::Enum(_, ref hir_generics) | hir::ItemKind::Union(_, ref hir_generics) = item.kind diff --git a/compiler/rustc_lint/src/late.rs b/compiler/rustc_lint/src/late.rs index 4cbddc0969d1f..860fa7fd8e39c 100644 --- a/compiler/rustc_lint/src/late.rs +++ b/compiler/rustc_lint/src/late.rs @@ -142,8 +142,8 @@ impl<'tcx, T: LateLintPass<'tcx>> hir_visit::Visitor<'tcx> for LateContextAndPas self.context.generics = it.kind.generics(); let old_cached_typeck_results = self.context.cached_typeck_results.take(); let old_enclosing_body = self.context.enclosing_body.take(); - self.with_lint_attrs(it.hir_id, &it.attrs, |cx| { - cx.with_param_env(it.hir_id, |cx| { + self.with_lint_attrs(it.hir_id(), &it.attrs, |cx| { + cx.with_param_env(it.hir_id(), |cx| { lint_callback!(cx, check_item, it); hir_visit::walk_item(cx, it); lint_callback!(cx, check_item_post, it); diff --git a/compiler/rustc_lint/src/levels.rs b/compiler/rustc_lint/src/levels.rs index 1fc2bd0916757..18ed350e672fb 100644 --- a/compiler/rustc_lint/src/levels.rs +++ b/compiler/rustc_lint/src/levels.rs @@ -577,7 +577,7 @@ impl<'tcx> intravisit::Visitor<'tcx> for LintLevelMapBuilder<'_, 'tcx> { } fn visit_item(&mut self, it: &'tcx hir::Item<'tcx>) { - self.with_lint_attrs(it.hir_id, &it.attrs, |builder| { + self.with_lint_attrs(it.hir_id(), &it.attrs, |builder| { intravisit::walk_item(builder, it); }); } diff --git a/compiler/rustc_lint/src/traits.rs b/compiler/rustc_lint/src/traits.rs index b031c1108c66f..e632f29e672c0 100644 --- a/compiler/rustc_lint/src/traits.rs +++ b/compiler/rustc_lint/src/traits.rs @@ -47,8 +47,7 @@ impl<'tcx> LateLintPass<'tcx> for DropTraitConstraints { fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'tcx>) { use rustc_middle::ty::PredicateKind::*; - let def_id = cx.tcx.hir().local_def_id(item.hir_id); - let predicates = cx.tcx.explicit_predicates_of(def_id); + let predicates = cx.tcx.explicit_predicates_of(item.def_id); for &(predicate, span) in predicates.predicates { let trait_predicate = match predicate.kind().skip_binder() { Trait(trait_predicate, _constness) => trait_predicate, diff --git a/compiler/rustc_lint/src/types.rs b/compiler/rustc_lint/src/types.rs index af0f556557209..55ed0a7156c24 100644 --- a/compiler/rustc_lint/src/types.rs +++ b/compiler/rustc_lint/src/types.rs @@ -1308,8 +1308,7 @@ declare_lint_pass!(VariantSizeDifferences => [VARIANT_SIZE_DIFFERENCES]); impl<'tcx> LateLintPass<'tcx> for VariantSizeDifferences { fn check_item(&mut self, cx: &LateContext<'_>, it: &hir::Item<'_>) { if let hir::ItemKind::Enum(ref enum_definition, _) = it.kind { - let item_def_id = cx.tcx.hir().local_def_id(it.hir_id); - let t = cx.tcx.type_of(item_def_id); + let t = cx.tcx.type_of(it.def_id); let ty = cx.tcx.erase_regions(t); let layout = match cx.layout_of(ty) { Ok(layout) => layout, diff --git a/compiler/rustc_metadata/src/foreign_modules.rs b/compiler/rustc_metadata/src/foreign_modules.rs index 4785b6c379c22..f1ab8e1961adb 100644 --- a/compiler/rustc_metadata/src/foreign_modules.rs +++ b/compiler/rustc_metadata/src/foreign_modules.rs @@ -23,10 +23,7 @@ impl ItemLikeVisitor<'tcx> for Collector<'tcx> { let foreign_items = items.iter().map(|it| self.tcx.hir().local_def_id(it.id.hir_id).to_def_id()).collect(); - self.modules.push(ForeignModule { - foreign_items, - def_id: self.tcx.hir().local_def_id(it.hir_id).to_def_id(), - }); + self.modules.push(ForeignModule { foreign_items, def_id: it.def_id.to_def_id() }); } fn visit_trait_item(&mut self, _it: &'tcx hir::TraitItem<'tcx>) {} diff --git a/compiler/rustc_metadata/src/native_libs.rs b/compiler/rustc_metadata/src/native_libs.rs index 8d0994320e383..4d63b6d074af0 100644 --- a/compiler/rustc_metadata/src/native_libs.rs +++ b/compiler/rustc_metadata/src/native_libs.rs @@ -53,7 +53,7 @@ impl ItemLikeVisitor<'tcx> for Collector<'tcx> { name: None, kind: NativeLibKind::Unspecified, cfg: None, - foreign_module: Some(self.tcx.hir().local_def_id(it.hir_id).to_def_id()), + foreign_module: Some(it.def_id.to_def_id()), wasm_import_module: None, }; let mut kind_specified = false; diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs index 14ca51008bec5..33e6696970e52 100644 --- a/compiler/rustc_metadata/src/rmeta/encoder.rs +++ b/compiler/rustc_metadata/src/rmeta/encoder.rs @@ -7,7 +7,9 @@ use rustc_data_structures::stable_hasher::StableHasher; use rustc_data_structures::sync::{join, par_iter, Lrc, ParallelIterator}; use rustc_hir as hir; use rustc_hir::def::{CtorOf, DefKind}; -use rustc_hir::def_id::{CrateNum, DefId, DefIndex, LocalDefId, CRATE_DEF_INDEX, LOCAL_CRATE}; +use rustc_hir::def_id::{ + CrateNum, DefId, DefIndex, LocalDefId, CRATE_DEF_ID, CRATE_DEF_INDEX, LOCAL_CRATE, +}; use rustc_hir::definitions::DefPathData; use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor}; use rustc_hir::itemlikevisit::ItemLikeVisitor; @@ -431,7 +433,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> { fn encode_info_for_items(&mut self) { let krate = self.tcx.hir().krate(); - self.encode_info_for_mod(hir::CRATE_HIR_ID, &krate.item.module); + self.encode_info_for_mod(CRATE_DEF_ID, &krate.item.module); // Proc-macro crates only export proc-macro items, which are looked // up using `proc_macro_data` @@ -932,9 +934,8 @@ impl EncodeContext<'a, 'tcx> { self.encode_inferred_outlives(def_id); } - fn encode_info_for_mod(&mut self, id: hir::HirId, md: &hir::Mod<'_>) { + fn encode_info_for_mod(&mut self, local_def_id: LocalDefId, md: &hir::Mod<'_>) { let tcx = self.tcx; - let local_def_id = tcx.hir().local_def_id(id); let def_id = local_def_id.to_def_id(); debug!("EncodeContext::encode_info_for_mod({:?})", def_id); @@ -969,7 +970,7 @@ impl EncodeContext<'a, 'tcx> { record!(self.tables.children[def_id] <- &[]); } else { record!(self.tables.children[def_id] <- md.item_ids.iter().map(|item_id| { - tcx.hir().local_def_id(item_id.id).local_def_index + item_id.def_id.local_def_index })); } } @@ -1312,7 +1313,7 @@ impl EncodeContext<'a, 'tcx> { EntryKind::Fn(self.lazy(data)) } hir::ItemKind::Mod(ref m) => { - return self.encode_info_for_mod(item.hir_id, m); + return self.encode_info_for_mod(item.def_id, m); } hir::ItemKind::ForeignMod { .. } => EntryKind::ForeignMod, hir::ItemKind::GlobalAsm(..) => EntryKind::GlobalAsm, @@ -1850,10 +1851,9 @@ impl Visitor<'tcx> for EncodeContext<'a, 'tcx> { } fn visit_item(&mut self, item: &'tcx hir::Item<'tcx>) { intravisit::walk_item(self, item); - let def_id = self.tcx.hir().local_def_id(item.hir_id); match item.kind { hir::ItemKind::ExternCrate(_) | hir::ItemKind::Use(..) => {} // ignore these - _ => self.encode_info_for_item(def_id.to_def_id(), item), + _ => self.encode_info_for_item(item.def_id.to_def_id(), item), } self.encode_addl_info_for_item(item); } @@ -1920,7 +1920,6 @@ impl EncodeContext<'a, 'tcx> { /// so it's easier to do that here then to wait until we would encounter /// normally in the visitor walk. fn encode_addl_info_for_item(&mut self, item: &hir::Item<'_>) { - let def_id = self.tcx.hir().local_def_id(item.hir_id); match item.kind { hir::ItemKind::Static(..) | hir::ItemKind::Const(..) @@ -1936,7 +1935,7 @@ impl EncodeContext<'a, 'tcx> { // no sub-item recording needed in these cases } hir::ItemKind::Enum(..) => { - let def = self.tcx.adt_def(def_id.to_def_id()); + let def = self.tcx.adt_def(item.def_id.to_def_id()); self.encode_fields(def); for (i, variant) in def.variants.iter_enumerated() { @@ -1948,7 +1947,7 @@ impl EncodeContext<'a, 'tcx> { } } hir::ItemKind::Struct(ref struct_def, _) => { - let def = self.tcx.adt_def(def_id.to_def_id()); + let def = self.tcx.adt_def(item.def_id.to_def_id()); self.encode_fields(def); // If the struct has a constructor, encode it. @@ -1958,18 +1957,19 @@ impl EncodeContext<'a, 'tcx> { } } hir::ItemKind::Union(..) => { - let def = self.tcx.adt_def(def_id.to_def_id()); + let def = self.tcx.adt_def(item.def_id.to_def_id()); self.encode_fields(def); } hir::ItemKind::Impl { .. } => { for &trait_item_def_id in - self.tcx.associated_item_def_ids(def_id.to_def_id()).iter() + self.tcx.associated_item_def_ids(item.def_id.to_def_id()).iter() { self.encode_info_for_impl_item(trait_item_def_id); } } hir::ItemKind::Trait(..) => { - for &item_def_id in self.tcx.associated_item_def_ids(def_id.to_def_id()).iter() { + for &item_def_id in self.tcx.associated_item_def_ids(item.def_id.to_def_id()).iter() + { self.encode_info_for_trait_item(item_def_id); } } @@ -1985,15 +1985,14 @@ struct ImplVisitor<'tcx> { impl<'tcx, 'v> ItemLikeVisitor<'v> for ImplVisitor<'tcx> { fn visit_item(&mut self, item: &hir::Item<'_>) { if let hir::ItemKind::Impl { .. } = item.kind { - let impl_id = self.tcx.hir().local_def_id(item.hir_id); - if let Some(trait_ref) = self.tcx.impl_trait_ref(impl_id.to_def_id()) { + if let Some(trait_ref) = self.tcx.impl_trait_ref(item.def_id.to_def_id()) { let simplified_self_ty = ty::fast_reject::simplify_type(self.tcx, trait_ref.self_ty(), false); self.impls .entry(trait_ref.def_id) .or_default() - .push((impl_id.local_def_index, simplified_self_ty)); + .push((item.def_id.local_def_index, simplified_self_ty)); } } } diff --git a/compiler/rustc_middle/src/hir/map/blocks.rs b/compiler/rustc_middle/src/hir/map/blocks.rs index 9d392c7b26bf7..3f323eb76c45e 100644 --- a/compiler/rustc_middle/src/hir/map/blocks.rs +++ b/compiler/rustc_middle/src/hir/map/blocks.rs @@ -215,7 +215,7 @@ impl<'a> FnLikeNode<'a> { match self.node { Node::Item(i) => match i.kind { hir::ItemKind::Fn(ref sig, ref generics, block) => item_fn(ItemFnParts { - id: i.hir_id, + id: i.hir_id(), ident: i.ident, decl: &sig.decl, body: block, diff --git a/compiler/rustc_middle/src/hir/map/collector.rs b/compiler/rustc_middle/src/hir/map/collector.rs index 358b0deec8c7e..31446f4ef7d2f 100644 --- a/compiler/rustc_middle/src/hir/map/collector.rs +++ b/compiler/rustc_middle/src/hir/map/collector.rs @@ -338,13 +338,10 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> { fn visit_item(&mut self, i: &'hir Item<'hir>) { debug!("visit_item: {:?}", i); - debug_assert_eq!( - i.hir_id.owner, - self.definitions.opt_hir_id_to_local_def_id(i.hir_id).unwrap() - ); - self.with_dep_node_owner(i.hir_id.owner, i, |this, hash| { - this.insert_with_hash(i.span, i.hir_id, Node::Item(i), hash); - this.with_parent(i.hir_id, |this| { + self.with_dep_node_owner(i.def_id, i, |this, hash| { + let hir_id = i.hir_id(); + this.insert_with_hash(i.span, hir_id, Node::Item(i), hash); + this.with_parent(hir_id, |this| { if let ItemKind::Struct(ref struct_def, _) = i.kind { // If this is a tuple or unit-like struct, register the constructor. if let Some(ctor_hir_id) = struct_def.ctor_hir_id() { diff --git a/compiler/rustc_middle/src/hir/map/mod.rs b/compiler/rustc_middle/src/hir/map/mod.rs index f06dc7536765f..948e6e60c56d5 100644 --- a/compiler/rustc_middle/src/hir/map/mod.rs +++ b/compiler/rustc_middle/src/hir/map/mod.rs @@ -301,7 +301,7 @@ impl<'hir> Map<'hir> { } pub fn item(&self, id: ItemId) -> &'hir Item<'hir> { - match self.find(id.id).unwrap() { + match self.find(id.hir_id()).unwrap() { Node::Item(item) => item, _ => bug!(), } diff --git a/compiler/rustc_middle/src/ich/impls_hir.rs b/compiler/rustc_middle/src/ich/impls_hir.rs index c6291c1c5250d..5ef70a89051ea 100644 --- a/compiler/rustc_middle/src/ich/impls_hir.rs +++ b/compiler/rustc_middle/src/ich/impls_hir.rs @@ -55,8 +55,7 @@ impl<'ctx> rustc_hir::HashStableContext for StableHashingContext<'ctx> { let item_ids_hash = item_ids .iter() .map(|id| { - let (def_path_hash, local_id) = id.to_stable_hash_key(hcx); - debug_assert_eq!(local_id, hir::ItemLocalId::from_u32(0)); + let def_path_hash = id.to_stable_hash_key(hcx); def_path_hash.0 }) .fold(Fingerprint::ZERO, |a, b| a.combine_commutative(b)); diff --git a/compiler/rustc_middle/src/mir/mono.rs b/compiler/rustc_middle/src/mir/mono.rs index a4b641ef83a87..6c2468b9ffe0b 100644 --- a/compiler/rustc_middle/src/mir/mono.rs +++ b/compiler/rustc_middle/src/mir/mono.rs @@ -72,8 +72,7 @@ impl<'tcx> MonoItem<'tcx> { MonoItem::Fn(instance) => tcx.symbol_name(instance), MonoItem::Static(def_id) => tcx.symbol_name(Instance::mono(tcx, def_id)), MonoItem::GlobalAsm(item_id) => { - let def_id = tcx.hir().local_def_id(item_id.hir_id()); - SymbolName::new(tcx, &format!("global_asm_{:?}", def_id)) + SymbolName::new(tcx, &format!("global_asm_{:?}", item_id.def_id)) } } } diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs index a8d9995bd0b2f..286041a7c548b 100644 --- a/compiler/rustc_middle/src/ty/print/pretty.rs +++ b/compiler/rustc_middle/src/ty/print/pretty.rs @@ -2107,11 +2107,9 @@ fn for_each_def(tcx: TyCtxt<'_>, mut collect_fn: impl for<'b> FnMut(&'b Ident, N continue; } - if let Some(local_def_id) = hir.definitions().opt_hir_id_to_local_def_id(item.hir_id) { - let def_id = local_def_id.to_def_id(); - let ns = tcx.def_kind(def_id).ns().unwrap_or(Namespace::TypeNS); - collect_fn(&item.ident, ns, def_id); - } + let def_id = item.def_id.to_def_id(); + let ns = tcx.def_kind(def_id).ns().unwrap_or(Namespace::TypeNS); + collect_fn(&item.ident, ns, def_id); } // Now take care of extern crate items. diff --git a/compiler/rustc_mir/src/monomorphize/collector.rs b/compiler/rustc_mir/src/monomorphize/collector.rs index 1cf809bef450d..b32a8c45f1a5f 100644 --- a/compiler/rustc_mir/src/monomorphize/collector.rs +++ b/compiler/rustc_mir/src/monomorphize/collector.rs @@ -1013,13 +1013,12 @@ impl ItemLikeVisitor<'v> for RootCollector<'_, 'v> { | hir::ItemKind::Union(_, ref generics) => { if generics.params.is_empty() { if self.mode == MonoItemCollectionMode::Eager { - let def_id = self.tcx.hir().local_def_id(item.hir_id); debug!( "RootCollector: ADT drop-glue for {}", - self.tcx.def_path_str(def_id.to_def_id()) + self.tcx.def_path_str(item.def_id.to_def_id()) ); - let ty = Instance::new(def_id.to_def_id(), InternalSubsts::empty()) + let ty = Instance::new(item.def_id.to_def_id(), InternalSubsts::empty()) .ty(self.tcx, ty::ParamEnv::reveal_all()); visit_drop_use(self.tcx, ty, true, DUMMY_SP, self.output); } @@ -1028,29 +1027,28 @@ impl ItemLikeVisitor<'v> for RootCollector<'_, 'v> { hir::ItemKind::GlobalAsm(..) => { debug!( "RootCollector: ItemKind::GlobalAsm({})", - self.tcx.def_path_str(self.tcx.hir().local_def_id(item.hir_id).to_def_id()) + self.tcx.def_path_str(item.def_id.to_def_id()) ); self.output.push(dummy_spanned(MonoItem::GlobalAsm(item.item_id()))); } hir::ItemKind::Static(..) => { - let def_id = self.tcx.hir().local_def_id(item.hir_id).to_def_id(); - debug!("RootCollector: ItemKind::Static({})", self.tcx.def_path_str(def_id)); - self.output.push(dummy_spanned(MonoItem::Static(def_id))); + debug!( + "RootCollector: ItemKind::Static({})", + self.tcx.def_path_str(item.def_id.to_def_id()) + ); + self.output.push(dummy_spanned(MonoItem::Static(item.def_id.to_def_id()))); } hir::ItemKind::Const(..) => { // const items only generate mono items if they are // actually used somewhere. Just declaring them is insufficient. // but even just declaring them must collect the items they refer to - let def_id = self.tcx.hir().local_def_id(item.hir_id); - - if let Ok(val) = self.tcx.const_eval_poly(def_id.to_def_id()) { + if let Ok(val) = self.tcx.const_eval_poly(item.def_id.to_def_id()) { collect_const_value(self.tcx, val, &mut self.output); } } hir::ItemKind::Fn(..) => { - let def_id = self.tcx.hir().local_def_id(item.hir_id); - self.push_if_root(def_id); + self.push_if_root(item.def_id); } } } @@ -1156,14 +1154,12 @@ fn create_mono_items_for_default_impls<'tcx>( } } - let impl_def_id = tcx.hir().local_def_id(item.hir_id); - debug!( "create_mono_items_for_default_impls(item={})", - tcx.def_path_str(impl_def_id.to_def_id()) + tcx.def_path_str(item.def_id.to_def_id()) ); - if let Some(trait_ref) = tcx.impl_trait_ref(impl_def_id) { + if let Some(trait_ref) = tcx.impl_trait_ref(item.def_id) { let param_env = ty::ParamEnv::reveal_all(); let trait_ref = tcx.normalize_erasing_regions(param_env, trait_ref); let overridden_methods: FxHashSet<_> = diff --git a/compiler/rustc_mir/src/monomorphize/partitioning/default.rs b/compiler/rustc_mir/src/monomorphize/partitioning/default.rs index f814da786e5af..edd46310f20d4 100644 --- a/compiler/rustc_mir/src/monomorphize/partitioning/default.rs +++ b/compiler/rustc_mir/src/monomorphize/partitioning/default.rs @@ -314,7 +314,7 @@ fn characteristic_def_id_of_mono_item<'tcx>( Some(def_id) } MonoItem::Static(def_id) => Some(def_id), - MonoItem::GlobalAsm(item_id) => Some(tcx.hir().local_def_id(item_id.hir_id()).to_def_id()), + MonoItem::GlobalAsm(item_id) => Some(item_id.def_id.to_def_id()), } } @@ -406,10 +406,9 @@ fn mono_item_visibility( }; } MonoItem::GlobalAsm(item_id) => { - let def_id = tcx.hir().local_def_id(item_id.hir_id()); - return if tcx.is_reachable_non_generic(def_id) { + return if tcx.is_reachable_non_generic(item_id.def_id) { *can_be_internalized = false; - default_visibility(tcx, def_id.to_def_id(), false) + default_visibility(tcx, item_id.def_id.to_def_id(), false) } else { Visibility::Hidden }; diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs index 2c79eeeb0e6d2..3c12f64ed21be 100644 --- a/compiler/rustc_passes/src/check_attr.rs +++ b/compiler/rustc_passes/src/check_attr.rs @@ -1058,7 +1058,7 @@ impl Visitor<'tcx> for CheckAttrVisitor<'tcx> { fn visit_item(&mut self, item: &'tcx Item<'tcx>) { let target = Target::from_item(item); self.check_attributes( - item.hir_id, + item.hir_id(), item.attrs, &item.span, target, diff --git a/compiler/rustc_passes/src/dead.rs b/compiler/rustc_passes/src/dead.rs index a9e843dd176c8..559fd4d6ea573 100644 --- a/compiler/rustc_passes/src/dead.rs +++ b/compiler/rustc_passes/src/dead.rs @@ -188,8 +188,7 @@ impl<'tcx> MarkSymbolVisitor<'tcx> { match node { Node::Item(item) => match item.kind { hir::ItemKind::Struct(..) | hir::ItemKind::Union(..) => { - let def_id = self.tcx.hir().local_def_id(item.hir_id); - let def = self.tcx.adt_def(def_id); + let def = self.tcx.adt_def(item.def_id); self.repr_has_repr_c = def.repr.c(); intravisit::walk_item(self, &item); @@ -395,9 +394,10 @@ struct LifeSeeder<'k, 'tcx> { impl<'v, 'k, 'tcx> ItemLikeVisitor<'v> for LifeSeeder<'k, 'tcx> { fn visit_item(&mut self, item: &hir::Item<'_>) { - let allow_dead_code = has_allow_dead_code_or_lang_attr(self.tcx, item.hir_id, &item.attrs); + let allow_dead_code = + has_allow_dead_code_or_lang_attr(self.tcx, item.hir_id(), &item.attrs); if allow_dead_code { - self.worklist.push(item.hir_id); + self.worklist.push(item.hir_id()); } match item.kind { hir::ItemKind::Enum(ref enum_def, _) => { @@ -413,7 +413,7 @@ impl<'v, 'k, 'tcx> ItemLikeVisitor<'v> for LifeSeeder<'k, 'tcx> { } hir::ItemKind::Impl(hir::Impl { ref of_trait, items, .. }) => { if of_trait.is_some() { - self.worklist.push(item.hir_id); + self.worklist.push(item.hir_id()); } for impl_item_ref in items { let impl_item = self.krate.impl_item(impl_item_ref.id); @@ -430,7 +430,7 @@ impl<'v, 'k, 'tcx> ItemLikeVisitor<'v> for LifeSeeder<'k, 'tcx> { } hir::ItemKind::Struct(ref variant_data, _) => { if let Some(ctor_hir_id) = variant_data.ctor_hir_id() { - self.struct_constructors.insert(ctor_hir_id, item.hir_id); + self.struct_constructors.insert(ctor_hir_id, item.hir_id()); } } _ => (), @@ -525,7 +525,7 @@ impl DeadVisitor<'tcx> { | hir::ItemKind::Struct(..) | hir::ItemKind::Union(..) ); - should_warn && !self.symbol_is_live(item.hir_id) + should_warn && !self.symbol_is_live(item.hir_id()) } fn should_warn_about_field(&mut self, field: &hir::StructField<'_>) -> bool { @@ -627,7 +627,7 @@ impl Visitor<'tcx> for DeadVisitor<'tcx> { hir::ItemKind::Struct(..) => "constructed", // Issue #52325 _ => "used", }; - self.warn_dead_code(item.hir_id, span, item.ident.name, participle); + self.warn_dead_code(item.hir_id(), span, item.ident.name, participle); } else { // Only continue if we didn't warn intravisit::walk_item(self, item); diff --git a/compiler/rustc_passes/src/diagnostic_items.rs b/compiler/rustc_passes/src/diagnostic_items.rs index 699c96bc49d59..919dc8864dcb9 100644 --- a/compiler/rustc_passes/src/diagnostic_items.rs +++ b/compiler/rustc_passes/src/diagnostic_items.rs @@ -27,7 +27,7 @@ struct DiagnosticItemCollector<'tcx> { impl<'v, 'tcx> ItemLikeVisitor<'v> for DiagnosticItemCollector<'tcx> { fn visit_item(&mut self, item: &hir::Item<'_>) { - self.observe_item(&item.attrs, item.hir_id); + self.observe_item(&item.attrs, item.hir_id()); } fn visit_trait_item(&mut self, trait_item: &hir::TraitItem<'_>) { diff --git a/compiler/rustc_passes/src/entry.rs b/compiler/rustc_passes/src/entry.rs index 5ff631a24573f..0d3a7ea3a8a00 100644 --- a/compiler/rustc_passes/src/entry.rs +++ b/compiler/rustc_passes/src/entry.rs @@ -32,8 +32,7 @@ struct EntryContext<'a, 'tcx> { impl<'a, 'tcx> ItemLikeVisitor<'tcx> for EntryContext<'a, 'tcx> { fn visit_item(&mut self, item: &'tcx Item<'tcx>) { - let def_id = self.map.local_def_id(item.hir_id); - let def_key = self.map.def_key(def_id); + let def_key = self.map.def_key(item.def_id); let at_root = def_key.parent == Some(CRATE_DEF_INDEX); find_item(item, self, at_root); } @@ -116,18 +115,18 @@ fn find_item(item: &Item<'_>, ctxt: &mut EntryContext<'_, '_>, at_root: bool) { } EntryPointType::MainNamed => { if ctxt.main_fn.is_none() { - ctxt.main_fn = Some((item.hir_id, item.span)); + ctxt.main_fn = Some((item.hir_id(), item.span)); } else { struct_span_err!(ctxt.session, item.span, E0136, "multiple `main` functions") .emit(); } } EntryPointType::OtherMain => { - ctxt.non_main_fns.push((item.hir_id, item.span)); + ctxt.non_main_fns.push((item.hir_id(), item.span)); } EntryPointType::MainAttr => { if ctxt.attr_main_fn.is_none() { - ctxt.attr_main_fn = Some((item.hir_id, item.span)); + ctxt.attr_main_fn = Some((item.hir_id(), item.span)); } else { struct_span_err!( ctxt.session, @@ -142,7 +141,7 @@ fn find_item(item: &Item<'_>, ctxt: &mut EntryContext<'_, '_>, at_root: bool) { } EntryPointType::Start => { if ctxt.start_fn.is_none() { - ctxt.start_fn = Some((item.hir_id, item.span)); + ctxt.start_fn = Some((item.hir_id(), item.span)); } else { struct_span_err!(ctxt.session, item.span, E0138, "multiple `start` functions") .span_label(ctxt.start_fn.unwrap().1, "previous `#[start]` function here") diff --git a/compiler/rustc_passes/src/hir_id_validator.rs b/compiler/rustc_passes/src/hir_id_validator.rs index fdd6c23805564..4e3010777c1ef 100644 --- a/compiler/rustc_passes/src/hir_id_validator.rs +++ b/compiler/rustc_passes/src/hir_id_validator.rs @@ -56,7 +56,7 @@ impl<'a, 'hir> OuterVisitor<'a, 'hir> { impl<'a, 'hir> ItemLikeVisitor<'hir> for OuterVisitor<'a, 'hir> { fn visit_item(&mut self, i: &'hir hir::Item<'hir>) { let mut inner_visitor = self.new_inner_visitor(self.hir_map); - inner_visitor.check(i.hir_id, |this| intravisit::walk_item(this, i)); + inner_visitor.check(i.hir_id(), |this| intravisit::walk_item(this, i)); } fn visit_trait_item(&mut self, i: &'hir hir::TraitItem<'hir>) { diff --git a/compiler/rustc_passes/src/hir_stats.rs b/compiler/rustc_passes/src/hir_stats.rs index 89acccdde5d73..cf29a55bee0d7 100644 --- a/compiler/rustc_passes/src/hir_stats.rs +++ b/compiler/rustc_passes/src/hir_stats.rs @@ -120,7 +120,7 @@ impl<'v> hir_visit::Visitor<'v> for StatCollector<'v> { } fn visit_item(&mut self, i: &'v hir::Item<'v>) { - self.record("Item", Id::Node(i.hir_id), i); + self.record("Item", Id::Node(i.hir_id()), i); hir_visit::walk_item(self, i) } diff --git a/compiler/rustc_passes/src/lang_items.rs b/compiler/rustc_passes/src/lang_items.rs index 3132661e5f516..a81ee22e464c2 100644 --- a/compiler/rustc_passes/src/lang_items.rs +++ b/compiler/rustc_passes/src/lang_items.rs @@ -30,7 +30,7 @@ struct LanguageItemCollector<'tcx> { impl ItemLikeVisitor<'v> for LanguageItemCollector<'tcx> { fn visit_item(&mut self, item: &hir::Item<'_>) { - self.check_for_lang(Target::from_item(item), item.hir_id, item.attrs); + self.check_for_lang(Target::from_item(item), item.hir_id(), item.attrs); if let hir::ItemKind::Enum(def, ..) = &item.kind { for variant in def.variants { diff --git a/compiler/rustc_passes/src/layout_test.rs b/compiler/rustc_passes/src/layout_test.rs index 9e83cbd668050..18c1d647060b1 100644 --- a/compiler/rustc_passes/src/layout_test.rs +++ b/compiler/rustc_passes/src/layout_test.rs @@ -21,16 +21,14 @@ struct LayoutTest<'tcx> { impl ItemLikeVisitor<'tcx> for LayoutTest<'tcx> { fn visit_item(&mut self, item: &'tcx hir::Item<'tcx>) { - let item_def_id = self.tcx.hir().local_def_id(item.hir_id); - match item.kind { ItemKind::TyAlias(..) | ItemKind::Enum(..) | ItemKind::Struct(..) | ItemKind::Union(..) => { - for attr in self.tcx.get_attrs(item_def_id.to_def_id()).iter() { + for attr in self.tcx.get_attrs(item.def_id.to_def_id()).iter() { if self.tcx.sess.check_name(attr, sym::rustc_layout) { - self.dump_layout_of(item_def_id, item, attr); + self.dump_layout_of(item.def_id, item, attr); } } } diff --git a/compiler/rustc_passes/src/reachable.rs b/compiler/rustc_passes/src/reachable.rs index eb24c51c54c35..36d335a81df3f 100644 --- a/compiler/rustc_passes/src/reachable.rs +++ b/compiler/rustc_passes/src/reachable.rs @@ -31,7 +31,7 @@ fn item_might_be_inlined(tcx: TyCtxt<'tcx>, item: &hir::Item<'_>, attrs: &Codege match item.kind { hir::ItemKind::Fn(ref sig, ..) if sig.header.is_const() => true, hir::ItemKind::Impl { .. } | hir::ItemKind::Fn(..) => { - let generics = tcx.generics_of(tcx.hir().local_def_id(item.hir_id)); + let generics = tcx.generics_of(item.def_id); generics.requires_monomorphization(tcx) } _ => false, @@ -218,8 +218,7 @@ impl<'tcx> ReachableContext<'tcx> { } else { false }; - let def_id = self.tcx.hir().local_def_id(item.hir_id); - let codegen_attrs = self.tcx.codegen_fn_attrs(def_id); + let codegen_attrs = self.tcx.codegen_fn_attrs(item.def_id); let is_extern = codegen_attrs.contains_extern_indicator(); let std_internal = codegen_attrs.flags.contains(CodegenFnAttrFlags::RUSTC_STD_INTERNAL_SYMBOL); @@ -239,9 +238,11 @@ impl<'tcx> ReachableContext<'tcx> { Node::Item(item) => { match item.kind { hir::ItemKind::Fn(.., body) => { - let def_id = self.tcx.hir().local_def_id(item.hir_id); - if item_might_be_inlined(self.tcx, &item, self.tcx.codegen_fn_attrs(def_id)) - { + if item_might_be_inlined( + self.tcx, + &item, + self.tcx.codegen_fn_attrs(item.def_id), + ) { self.visit_nested_body(body); } } @@ -341,19 +342,18 @@ impl<'a, 'tcx> ItemLikeVisitor<'tcx> for CollectPrivateImplItemsVisitor<'a, 'tcx // Anything which has custom linkage gets thrown on the worklist no // matter where it is in the crate, along with "special std symbols" // which are currently akin to allocator symbols. - let def_id = self.tcx.hir().local_def_id(item.hir_id); - let codegen_attrs = self.tcx.codegen_fn_attrs(def_id); + let codegen_attrs = self.tcx.codegen_fn_attrs(item.def_id); if codegen_attrs.contains_extern_indicator() || codegen_attrs.flags.contains(CodegenFnAttrFlags::RUSTC_STD_INTERNAL_SYMBOL) { - self.worklist.push(def_id); + self.worklist.push(item.def_id); } // We need only trait impls here, not inherent impls, and only non-exported ones if let hir::ItemKind::Impl(hir::Impl { of_trait: Some(ref trait_ref), ref items, .. }) = item.kind { - if !self.access_levels.is_reachable(item.hir_id) { + if !self.access_levels.is_reachable(item.hir_id()) { // FIXME(#53488) remove `let` let tcx = self.tcx; self.worklist diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs index e1d03e3504800..c99784f827902 100644 --- a/compiler/rustc_passes/src/stability.rs +++ b/compiler/rustc_passes/src/stability.rs @@ -376,7 +376,7 @@ impl<'a, 'tcx> Visitor<'tcx> for Annotator<'a, 'tcx> { } self.annotate( - i.hir_id, + i.hir_id(), &i.attrs, i.span, kind, @@ -556,7 +556,7 @@ impl<'tcx> Visitor<'tcx> for MissingStabilityAnnotations<'tcx> { hir::ItemKind::Impl(hir::Impl { of_trait: None, .. }) | hir::ItemKind::ForeignMod { .. } ) { - self.check_missing_stability(i.hir_id, i.span); + self.check_missing_stability(i.hir_id(), i.span); } // Ensure `const fn` that are `stable` have one of `rustc_const_unstable` or @@ -564,7 +564,7 @@ impl<'tcx> Visitor<'tcx> for MissingStabilityAnnotations<'tcx> { if self.tcx.features().staged_api && matches!(&i.kind, hir::ItemKind::Fn(sig, ..) if sig.header.is_const()) { - self.check_missing_const_stability(i.hir_id, i.span); + self.check_missing_const_stability(i.hir_id(), i.span); } intravisit::walk_item(self, i) @@ -712,13 +712,12 @@ impl Visitor<'tcx> for Checker<'tcx> { return; } - let def_id = self.tcx.hir().local_def_id(item.hir_id); - let cnum = match self.tcx.extern_mod_stmt_cnum(def_id) { + let cnum = match self.tcx.extern_mod_stmt_cnum(item.def_id) { Some(cnum) => cnum, None => return, }; let def_id = DefId { krate: cnum, index: CRATE_DEF_INDEX }; - self.tcx.check_stability(def_id, Some(item.hir_id), item.span); + self.tcx.check_stability(def_id, Some(item.hir_id()), item.span); } // For implementations of traits, check the stability of each item @@ -744,7 +743,7 @@ impl Visitor<'tcx> for Checker<'tcx> { .map_or(item.span, |a| a.span); self.tcx.struct_span_lint_hir( INEFFECTIVE_UNSTABLE_TRAIT_IMPL, - item.hir_id, + item.hir_id(), span, |lint| lint .build("an `#[unstable]` annotation here has no effect") @@ -775,15 +774,14 @@ impl Visitor<'tcx> for Checker<'tcx> { // There's no good place to insert stability check for non-Copy unions, // so semi-randomly perform it here in stability.rs hir::ItemKind::Union(..) if !self.tcx.features().untagged_unions => { - let def_id = self.tcx.hir().local_def_id(item.hir_id); - let ty = self.tcx.type_of(def_id); + let ty = self.tcx.type_of(item.def_id); let (adt_def, substs) = match ty.kind() { ty::Adt(adt_def, substs) => (adt_def, substs), _ => bug!(), }; // Non-`Copy` fields are unstable, except for `ManuallyDrop`. - let param_env = self.tcx.param_env(def_id); + let param_env = self.tcx.param_env(item.def_id); for field in &adt_def.non_enum_variant().fields { let field_ty = field.ty(self.tcx, substs); if !field_ty.ty_adt_def().map_or(false, |adt_def| adt_def.is_manually_drop()) diff --git a/compiler/rustc_plugin_impl/src/build.rs b/compiler/rustc_plugin_impl/src/build.rs index 4796d9a80b69a..d5c287fb3bcb3 100644 --- a/compiler/rustc_plugin_impl/src/build.rs +++ b/compiler/rustc_plugin_impl/src/build.rs @@ -1,7 +1,7 @@ //! Used by `rustc` when compiling a plugin crate. use rustc_hir as hir; -use rustc_hir::def_id::{CrateNum, DefId, LOCAL_CRATE}; +use rustc_hir::def_id::{CrateNum, DefId, LocalDefId, LOCAL_CRATE}; use rustc_hir::itemlikevisit::ItemLikeVisitor; use rustc_middle::ty::query::Providers; use rustc_middle::ty::TyCtxt; @@ -10,14 +10,14 @@ use rustc_span::Span; struct RegistrarFinder<'tcx> { tcx: TyCtxt<'tcx>, - registrars: Vec<(hir::HirId, Span)>, + registrars: Vec<(LocalDefId, Span)>, } impl<'v, 'tcx> ItemLikeVisitor<'v> for RegistrarFinder<'tcx> { fn visit_item(&mut self, item: &hir::Item<'_>) { if let hir::ItemKind::Fn(..) = item.kind { if self.tcx.sess.contains_name(&item.attrs, sym::plugin_registrar) { - self.registrars.push((item.hir_id, item.span)); + self.registrars.push((item.def_id, item.span)); } } } @@ -43,8 +43,8 @@ fn plugin_registrar_fn(tcx: TyCtxt<'_>, cnum: CrateNum) -> Option { match finder.registrars.len() { 0 => None, 1 => { - let (hir_id, _) = finder.registrars.pop().unwrap(); - Some(tcx.hir().local_def_id(hir_id).to_def_id()) + let (def_id, _) = finder.registrars.pop().unwrap(); + Some(def_id.to_def_id()) } _ => { let diagnostic = tcx.sess.diagnostic(); diff --git a/compiler/rustc_privacy/src/lib.rs b/compiler/rustc_privacy/src/lib.rs index 48c4c1c2d5461..d79e9cf505b36 100644 --- a/compiler/rustc_privacy/src/lib.rs +++ b/compiler/rustc_privacy/src/lib.rs @@ -454,11 +454,9 @@ impl EmbargoVisitor<'tcx> { let module_def_id = self.tcx.hir().local_def_id(reachable_mod); let module = self.tcx.hir().get_module(module_def_id).0; for item_id in module.item_ids { - let hir_id = item_id.id; - let item_def_id = self.tcx.hir().local_def_id(hir_id); - let def_kind = self.tcx.def_kind(item_def_id); - let vis = self.tcx.visibility(item_def_id); - self.update_macro_reachable_def(hir_id, def_kind, vis, defining_mod); + let def_kind = self.tcx.def_kind(item_id.def_id); + let vis = self.tcx.visibility(item_id.def_id); + self.update_macro_reachable_def(item_id.hir_id(), def_kind, vis, defining_mod); } if let Some(exports) = self.tcx.module_exports(module_def_id) { for export in exports { @@ -590,12 +588,15 @@ impl EmbargoVisitor<'tcx> { if let hir::ItemKind::Mod(m) = &item.kind { for &item_id in m.item_ids { let item = self.tcx.hir().item(item_id); - let def_id = self.tcx.hir().local_def_id(item_id.id); - if !self.tcx.hygienic_eq(segment.ident, item.ident, def_id.to_def_id()) { + if !self.tcx.hygienic_eq( + segment.ident, + item.ident, + item_id.def_id.to_def_id(), + ) { continue; } if let hir::ItemKind::Use(..) = item.kind { - self.update(item.hir_id, Some(AccessLevel::Exported)); + self.update(item.hir_id(), Some(AccessLevel::Exported)); } } } @@ -616,7 +617,7 @@ impl Visitor<'tcx> for EmbargoVisitor<'tcx> { fn visit_item(&mut self, item: &'tcx hir::Item<'tcx>) { let inherited_item_level = match item.kind { hir::ItemKind::Impl { .. } => { - Option::::of_impl(item.hir_id, self.tcx, &self.access_levels) + Option::::of_impl(item.hir_id(), self.tcx, &self.access_levels) } // Foreign modules inherit level from parents. hir::ItemKind::ForeignMod { .. } => self.prev_level, @@ -644,7 +645,7 @@ impl Visitor<'tcx> for EmbargoVisitor<'tcx> { }; // Update level of the item itself. - let item_level = self.update(item.hir_id, inherited_item_level); + let item_level = self.update(item.hir_id(), inherited_item_level); // Update levels of nested things. match item.kind { @@ -727,7 +728,7 @@ impl Visitor<'tcx> for EmbargoVisitor<'tcx> { // reachable if they are returned via `impl Trait`, even from private functions. let exist_level = cmp::max(item_level, Some(AccessLevel::ReachableFromImplTrait)); - self.reach(item.hir_id, exist_level).generics().predicates().ty(); + self.reach(item.hir_id(), exist_level).generics().predicates().ty(); } } // Visit everything. @@ -736,12 +737,12 @@ impl Visitor<'tcx> for EmbargoVisitor<'tcx> { | hir::ItemKind::Fn(..) | hir::ItemKind::TyAlias(..) => { if item_level.is_some() { - self.reach(item.hir_id, item_level).generics().predicates().ty(); + self.reach(item.hir_id(), item_level).generics().predicates().ty(); } } hir::ItemKind::Trait(.., trait_item_refs) => { if item_level.is_some() { - self.reach(item.hir_id, item_level).generics().predicates(); + self.reach(item.hir_id(), item_level).generics().predicates(); for trait_item_ref in trait_item_refs { let mut reach = self.reach(trait_item_ref.id.hir_id, item_level); @@ -759,13 +760,13 @@ impl Visitor<'tcx> for EmbargoVisitor<'tcx> { } hir::ItemKind::TraitAlias(..) => { if item_level.is_some() { - self.reach(item.hir_id, item_level).generics().predicates(); + self.reach(item.hir_id(), item_level).generics().predicates(); } } // Visit everything except for private impl items. hir::ItemKind::Impl(ref impl_) => { if item_level.is_some() { - self.reach(item.hir_id, item_level).generics().predicates().ty().trait_ref(); + self.reach(item.hir_id(), item_level).generics().predicates().ty().trait_ref(); for impl_item_ref in impl_.items { let impl_item_level = self.get(impl_item_ref.id.hir_id); @@ -782,7 +783,7 @@ impl Visitor<'tcx> for EmbargoVisitor<'tcx> { // Visit everything, but enum variants have their own levels. hir::ItemKind::Enum(ref def, _) => { if item_level.is_some() { - self.reach(item.hir_id, item_level).generics().predicates(); + self.reach(item.hir_id(), item_level).generics().predicates(); } for variant in def.variants { let variant_level = self.get(variant.id); @@ -792,7 +793,7 @@ impl Visitor<'tcx> for EmbargoVisitor<'tcx> { } // Corner case: if the variant is reachable, but its // enum is not, make the enum reachable as well. - self.update(item.hir_id, variant_level); + self.update(item.hir_id(), variant_level); } } } @@ -811,7 +812,7 @@ impl Visitor<'tcx> for EmbargoVisitor<'tcx> { // Visit everything except for private fields. hir::ItemKind::Struct(ref struct_def, _) | hir::ItemKind::Union(ref struct_def, _) => { if item_level.is_some() { - self.reach(item.hir_id, item_level).generics().predicates(); + self.reach(item.hir_id(), item_level).generics().predicates(); for field in struct_def.fields() { let field_level = self.get(field.hir_id); if field_level.is_some() { @@ -1037,7 +1038,7 @@ impl<'tcx> Visitor<'tcx> for NamePrivacyVisitor<'tcx> { } fn visit_item(&mut self, item: &'tcx hir::Item<'tcx>) { - let orig_current_item = self.current_item.replace(item.hir_id); + let orig_current_item = self.current_item.replace(item.hir_id()); intravisit::walk_item(self, item); self.current_item = orig_current_item; } @@ -1322,8 +1323,7 @@ impl<'tcx> Visitor<'tcx> for TypePrivacyVisitor<'tcx> { // Check types in item interfaces. fn visit_item(&mut self, item: &'tcx hir::Item<'tcx>) { - let orig_current_item = - mem::replace(&mut self.current_item, self.tcx.hir().local_def_id(item.hir_id)); + let orig_current_item = mem::replace(&mut self.current_item, item.def_id); let old_maybe_typeck_results = self.maybe_typeck_results.take(); intravisit::walk_item(self, item); self.maybe_typeck_results = old_maybe_typeck_results; @@ -1463,7 +1463,7 @@ impl<'a, 'tcx> Visitor<'tcx> for ObsoleteVisiblePrivateTypesVisitor<'a, 'tcx> { hir::ItemKind::ForeignMod { .. } => {} hir::ItemKind::Trait(.., ref bounds, _) => { - if !self.trait_is_public(item.hir_id) { + if !self.trait_is_public(item.hir_id()) { return; } @@ -1615,7 +1615,7 @@ impl<'a, 'tcx> Visitor<'tcx> for ObsoleteVisiblePrivateTypesVisitor<'a, 'tcx> { hir::ItemKind::TyAlias(..) => return, // Not at all public, so we don't care. - _ if !self.item_is_public(&item.hir_id, &item.vis) => { + _ if !self.item_is_public(&item.hir_id(), &item.vis) => { return; } @@ -1926,7 +1926,7 @@ impl<'a, 'tcx> Visitor<'tcx> for PrivateItemsInPublicInterfacesVisitor<'a, 'tcx> fn visit_item(&mut self, item: &'tcx hir::Item<'tcx>) { let tcx = self.tcx; - let item_visibility = tcx.visibility(tcx.hir().local_def_id(item.hir_id).to_def_id()); + let item_visibility = tcx.visibility(item.def_id); match item.kind { // Crates are always public. @@ -1942,15 +1942,15 @@ impl<'a, 'tcx> Visitor<'tcx> for PrivateItemsInPublicInterfacesVisitor<'a, 'tcx> | hir::ItemKind::Static(..) | hir::ItemKind::Fn(..) | hir::ItemKind::TyAlias(..) => { - self.check(item.hir_id, item_visibility).generics().predicates().ty(); + self.check(item.hir_id(), item_visibility).generics().predicates().ty(); } hir::ItemKind::OpaqueTy(..) => { // `ty()` for opaque types is the underlying type, // it's not a part of interface, so we skip it. - self.check(item.hir_id, item_visibility).generics().bounds(); + self.check(item.hir_id(), item_visibility).generics().bounds(); } hir::ItemKind::Trait(.., trait_item_refs) => { - self.check(item.hir_id, item_visibility).generics().predicates(); + self.check(item.hir_id(), item_visibility).generics().predicates(); for trait_item_ref in trait_item_refs { self.check_assoc_item( @@ -1966,10 +1966,10 @@ impl<'a, 'tcx> Visitor<'tcx> for PrivateItemsInPublicInterfacesVisitor<'a, 'tcx> } } hir::ItemKind::TraitAlias(..) => { - self.check(item.hir_id, item_visibility).generics().predicates(); + self.check(item.hir_id(), item_visibility).generics().predicates(); } hir::ItemKind::Enum(ref def, _) => { - self.check(item.hir_id, item_visibility).generics().predicates(); + self.check(item.hir_id(), item_visibility).generics().predicates(); for variant in def.variants { for field in variant.data.fields() { @@ -1986,7 +1986,7 @@ impl<'a, 'tcx> Visitor<'tcx> for PrivateItemsInPublicInterfacesVisitor<'a, 'tcx> } // Subitems of structs and unions have their own publicity. hir::ItemKind::Struct(ref struct_def, _) | hir::ItemKind::Union(ref struct_def, _) => { - self.check(item.hir_id, item_visibility).generics().predicates(); + self.check(item.hir_id(), item_visibility).generics().predicates(); for field in struct_def.fields() { let field_visibility = tcx.visibility(tcx.hir().local_def_id(field.hir_id)); @@ -1998,8 +1998,8 @@ impl<'a, 'tcx> Visitor<'tcx> for PrivateItemsInPublicInterfacesVisitor<'a, 'tcx> // A trait impl is public when both its type and its trait are public // Subitems of trait impls have inherited publicity. hir::ItemKind::Impl(ref impl_) => { - let impl_vis = ty::Visibility::of_impl(item.hir_id, tcx, &Default::default()); - self.check(item.hir_id, impl_vis).generics().predicates(); + let impl_vis = ty::Visibility::of_impl(item.hir_id(), tcx, &Default::default()); + self.check(item.hir_id(), impl_vis).generics().predicates(); for impl_item_ref in impl_.items { let impl_item_vis = if impl_.of_trait.is_none() { min( diff --git a/compiler/rustc_resolve/src/late/lifetimes.rs b/compiler/rustc_resolve/src/late/lifetimes.rs index 5f09b643c50c7..fa8af36ec211e 100644 --- a/compiler/rustc_resolve/src/late/lifetimes.rs +++ b/compiler/rustc_resolve/src/late/lifetimes.rs @@ -632,7 +632,8 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> { let hir_id = self.tcx.hir().local_def_id_to_hir_id(def_id); // Ensure that the parent of the def is an item, not HRTB let parent_id = self.tcx.hir().get_parent_node(hir_id); - let parent_item_id = hir::ItemId { id: parent_id }; + let parent_item_id = + hir::ItemId { def_id: parent_id.expect_owner() }; let parent_impl_id = hir::ImplItemId { hir_id: parent_id }; let parent_trait_id = hir::TraitItemId { hir_id: parent_id }; let krate = self.tcx.hir().krate(); @@ -1256,7 +1257,7 @@ fn compute_object_lifetime_defaults(tcx: TyCtxt<'_>) -> HirIdMap {} } diff --git a/compiler/rustc_save_analysis/src/dump_visitor.rs b/compiler/rustc_save_analysis/src/dump_visitor.rs index a5360dd313f37..1d807dd917c57 100644 --- a/compiler/rustc_save_analysis/src/dump_visitor.rs +++ b/compiler/rustc_save_analysis/src/dump_visitor.rs @@ -373,14 +373,14 @@ impl<'tcx> DumpVisitor<'tcx> { body: hir::BodyId, ) { let map = &self.tcx.hir(); - self.nest_typeck_results(map.local_def_id(item.hir_id), |v| { + self.nest_typeck_results(item.def_id, |v| { let body = map.body(body); if let Some(fn_data) = v.save_ctxt.get_item_data(item) { down_cast_data!(fn_data, DefData, item.span); v.process_formals(body.params, &fn_data.qualname); - v.process_generic_params(ty_params, &fn_data.qualname, item.hir_id); + v.process_generic_params(ty_params, &fn_data.qualname, item.hir_id()); - v.dumper.dump_def(&access_from!(v.save_ctxt, item, item.hir_id), fn_data); + v.dumper.dump_def(&access_from!(v.save_ctxt, item, item.hir_id()), fn_data); } for arg in decl.inputs { @@ -401,10 +401,10 @@ impl<'tcx> DumpVisitor<'tcx> { typ: &'tcx hir::Ty<'tcx>, expr: &'tcx hir::Expr<'tcx>, ) { - self.nest_typeck_results(self.tcx.hir().local_def_id(item.hir_id), |v| { + self.nest_typeck_results(item.def_id, |v| { if let Some(var_data) = v.save_ctxt.get_item_data(item) { down_cast_data!(var_data, DefData, item.span); - v.dumper.dump_def(&access_from!(v.save_ctxt, item, item.hir_id), var_data); + v.dumper.dump_def(&access_from!(v.save_ctxt, item, item.hir_id()), var_data); } v.visit_ty(&typ); v.visit_expr(expr); @@ -465,10 +465,7 @@ impl<'tcx> DumpVisitor<'tcx> { ) { debug!("process_struct {:?} {:?}", item, item.span); let name = item.ident.to_string(); - let qualname = format!( - "::{}", - self.tcx.def_path_str(self.tcx.hir().local_def_id(item.hir_id).to_def_id()) - ); + let qualname = format!("::{}", self.tcx.def_path_str(item.def_id.to_def_id())); let kind = match item.kind { hir::ItemKind::Struct(_, _) => DefKind::Struct, @@ -500,10 +497,10 @@ impl<'tcx> DumpVisitor<'tcx> { if !self.span.filter_generated(item.ident.span) { let span = self.span_from_span(item.ident.span); self.dumper.dump_def( - &access_from!(self.save_ctxt, item, item.hir_id), + &access_from!(self.save_ctxt, item, item.hir_id()), Def { kind, - id: id_from_hir_id(item.hir_id, &self.save_ctxt), + id: id_from_def_id(item.def_id.to_def_id()), span, name, qualname: qualname.clone(), @@ -518,13 +515,13 @@ impl<'tcx> DumpVisitor<'tcx> { ); } - self.nest_typeck_results(self.tcx.hir().local_def_id(item.hir_id), |v| { + self.nest_typeck_results(item.def_id, |v| { for field in def.fields() { - v.process_struct_field_def(field, item.hir_id); + v.process_struct_field_def(field, item.hir_id()); v.visit_ty(&field.ty); } - v.process_generic_params(ty_params, &qualname, item.hir_id); + v.process_generic_params(ty_params, &qualname, item.hir_id()); }); } @@ -541,7 +538,7 @@ impl<'tcx> DumpVisitor<'tcx> { }; down_cast_data!(enum_data, DefData, item.span); - let access = access_from!(self.save_ctxt, item, item.hir_id); + let access = access_from!(self.save_ctxt, item, item.hir_id()); for variant in enum_definition.variants { let name = variant.ident.name.to_string(); @@ -556,7 +553,7 @@ impl<'tcx> DumpVisitor<'tcx> { if !self.span.filter_generated(name_span) { let span = self.span_from_span(name_span); let id = id_from_hir_id(variant.id, &self.save_ctxt); - let parent = Some(id_from_hir_id(item.hir_id, &self.save_ctxt)); + let parent = Some(id_from_def_id(item.def_id.to_def_id())); self.dumper.dump_def( &access, @@ -596,7 +593,7 @@ impl<'tcx> DumpVisitor<'tcx> { if !self.span.filter_generated(name_span) { let span = self.span_from_span(name_span); let id = id_from_hir_id(variant.id, &self.save_ctxt); - let parent = Some(id_from_hir_id(item.hir_id, &self.save_ctxt)); + let parent = Some(id_from_def_id(item.def_id.to_def_id())); self.dumper.dump_def( &access, @@ -627,7 +624,7 @@ impl<'tcx> DumpVisitor<'tcx> { self.visit_ty(field.ty); } } - self.process_generic_params(ty_params, &enum_data.qualname, item.hir_id); + self.process_generic_params(ty_params, &enum_data.qualname, item.hir_id()); self.dumper.dump_def(&access, enum_data); } @@ -644,17 +641,14 @@ impl<'tcx> DumpVisitor<'tcx> { } let map = &self.tcx.hir(); - self.nest_typeck_results(map.local_def_id(item.hir_id), |v| { + self.nest_typeck_results(item.def_id, |v| { v.visit_ty(&impl_.self_ty); if let Some(trait_ref) = &impl_.of_trait { v.process_path(trait_ref.hir_ref_id, &hir::QPath::Resolved(None, &trait_ref.path)); } - v.process_generic_params(&impl_.generics, "", item.hir_id); + v.process_generic_params(&impl_.generics, "", item.hir_id()); for impl_item in impl_.items { - v.process_impl_item( - map.impl_item(impl_item.id), - map.local_def_id(item.hir_id).to_def_id(), - ); + v.process_impl_item(map.impl_item(impl_item.id), item.def_id.to_def_id()); } }); } @@ -667,10 +661,7 @@ impl<'tcx> DumpVisitor<'tcx> { methods: &'tcx [hir::TraitItemRef], ) { let name = item.ident.to_string(); - let qualname = format!( - "::{}", - self.tcx.def_path_str(self.tcx.hir().local_def_id(item.hir_id).to_def_id()) - ); + let qualname = format!("::{}", self.tcx.def_path_str(item.def_id.to_def_id())); let mut val = name.clone(); if !generics.params.is_empty() { val.push_str(&generic_params_to_string(generics.params)); @@ -680,12 +671,12 @@ impl<'tcx> DumpVisitor<'tcx> { val.push_str(&bounds_to_string(trait_refs)); } if !self.span.filter_generated(item.ident.span) { - let id = id_from_hir_id(item.hir_id, &self.save_ctxt); + let id = id_from_def_id(item.def_id.to_def_id()); let span = self.span_from_span(item.ident.span); let children = methods.iter().map(|i| id_from_hir_id(i.id.hir_id, &self.save_ctxt)).collect(); self.dumper.dump_def( - &access_from!(self.save_ctxt, item, item.hir_id), + &access_from!(self.save_ctxt, item, item.hir_id()), Def { kind: DefKind::Trait, id, @@ -729,20 +720,17 @@ impl<'tcx> DumpVisitor<'tcx> { kind: RelationKind::SuperTrait, span, from: id_from_def_id(id), - to: id_from_hir_id(item.hir_id, &self.save_ctxt), + to: id_from_def_id(item.def_id.to_def_id()), }); } } } // walk generics and methods - self.process_generic_params(generics, &qualname, item.hir_id); + self.process_generic_params(generics, &qualname, item.hir_id()); for method in methods { let map = &self.tcx.hir(); - self.process_trait_item( - map.trait_item(method.id), - map.local_def_id(item.hir_id).to_def_id(), - ) + self.process_trait_item(map.trait_item(method.id), item.def_id.to_def_id()) } } @@ -750,7 +738,7 @@ impl<'tcx> DumpVisitor<'tcx> { fn process_mod(&mut self, item: &'tcx hir::Item<'tcx>) { if let Some(mod_data) = self.save_ctxt.get_item_data(item) { down_cast_data!(mod_data, DefData, item.span); - self.dumper.dump_def(&access_from!(self.save_ctxt, item, item.hir_id), mod_data); + self.dumper.dump_def(&access_from!(self.save_ctxt, item, item.hir_id()), mod_data); } } @@ -1130,7 +1118,7 @@ impl<'tcx> DumpVisitor<'tcx> { .module .item_ids .iter() - .map(|i| id_from_hir_id(i.id, &self.save_ctxt)) + .map(|i| id_from_def_id(i.def_id.to_def_id())) .collect(); let span = self.span_from_span(krate.item.span); @@ -1179,16 +1167,11 @@ impl<'tcx> Visitor<'tcx> for DumpVisitor<'tcx> { hir::ItemKind::Use(path, hir::UseKind::Single) => { let sub_span = path.segments.last().unwrap().ident.span; if !self.span.filter_generated(sub_span) { - let access = access_from!(self.save_ctxt, item, item.hir_id); - let ref_id = self.lookup_def_id(item.hir_id).map(id_from_def_id); + let access = access_from!(self.save_ctxt, item, item.hir_id()); + let ref_id = self.lookup_def_id(item.hir_id()).map(id_from_def_id); let span = self.span_from_span(sub_span); - let parent = self - .save_ctxt - .tcx - .hir() - .opt_local_def_id(item.hir_id) - .and_then(|id| self.save_ctxt.tcx.parent(id.to_def_id())) - .map(id_from_def_id); + let parent = + self.save_ctxt.tcx.parent(item.def_id.to_def_id()).map(id_from_def_id); self.dumper.import( &access, Import { @@ -1206,23 +1189,17 @@ impl<'tcx> Visitor<'tcx> for DumpVisitor<'tcx> { } hir::ItemKind::Use(path, hir::UseKind::Glob) => { // Make a comma-separated list of names of imported modules. - let def_id = self.tcx.hir().local_def_id(item.hir_id); - let names = self.tcx.names_imported_by_glob_use(def_id); + let names = self.tcx.names_imported_by_glob_use(item.def_id); let names: Vec<_> = names.iter().map(|n| n.to_string()).collect(); // Otherwise it's a span with wrong macro expansion info, which // we don't want to track anyway, since it's probably macro-internal `use` if let Some(sub_span) = self.span.sub_span_of_star(item.span) { if !self.span.filter_generated(item.span) { - let access = access_from!(self.save_ctxt, item, item.hir_id); + let access = access_from!(self.save_ctxt, item, item.hir_id()); let span = self.span_from_span(sub_span); - let parent = self - .save_ctxt - .tcx - .hir() - .opt_local_def_id(item.hir_id) - .and_then(|id| self.save_ctxt.tcx.parent(id.to_def_id())) - .map(id_from_def_id); + let parent = + self.save_ctxt.tcx.parent(item.def_id.to_def_id()).map(id_from_def_id); self.dumper.import( &access, Import { @@ -1243,13 +1220,8 @@ impl<'tcx> Visitor<'tcx> for DumpVisitor<'tcx> { let name_span = item.ident.span; if !self.span.filter_generated(name_span) { let span = self.span_from_span(name_span); - let parent = self - .save_ctxt - .tcx - .hir() - .opt_local_def_id(item.hir_id) - .and_then(|id| self.save_ctxt.tcx.parent(id.to_def_id())) - .map(id_from_def_id); + let parent = + self.save_ctxt.tcx.parent(item.def_id.to_def_id()).map(id_from_def_id); self.dumper.import( &Access { public: false, reachable: false }, Import { @@ -1286,20 +1258,17 @@ impl<'tcx> Visitor<'tcx> for DumpVisitor<'tcx> { } hir::ItemKind::Mod(ref m) => { self.process_mod(item); - intravisit::walk_mod(self, m, item.hir_id); + intravisit::walk_mod(self, m, item.hir_id()); } hir::ItemKind::TyAlias(ty, ref generics) => { - let qualname = format!( - "::{}", - self.tcx.def_path_str(self.tcx.hir().local_def_id(item.hir_id).to_def_id()) - ); + let qualname = format!("::{}", self.tcx.def_path_str(item.def_id.to_def_id())); let value = ty_to_string(&ty); if !self.span.filter_generated(item.ident.span) { let span = self.span_from_span(item.ident.span); - let id = id_from_hir_id(item.hir_id, &self.save_ctxt); + let id = id_from_def_id(item.def_id.to_def_id()); self.dumper.dump_def( - &access_from!(self.save_ctxt, item, item.hir_id), + &access_from!(self.save_ctxt, item, item.hir_id()), Def { kind: DefKind::Type, id, @@ -1318,7 +1287,7 @@ impl<'tcx> Visitor<'tcx> for DumpVisitor<'tcx> { } self.visit_ty(ty); - self.process_generic_params(generics, &qualname, item.hir_id); + self.process_generic_params(generics, &qualname, item.hir_id()); } _ => intravisit::walk_item(self, item), } @@ -1383,9 +1352,7 @@ impl<'tcx> Visitor<'tcx> for DumpVisitor<'tcx> { } hir::TyKind::OpaqueDef(item_id, _) => { let item = self.tcx.hir().item(item_id); - self.nest_typeck_results(self.tcx.hir().local_def_id(item_id.id), |v| { - v.visit_item(item) - }); + self.nest_typeck_results(item_id.def_id, |v| v.visit_item(item)); } _ => intravisit::walk_ty(self, t), } diff --git a/compiler/rustc_save_analysis/src/lib.rs b/compiler/rustc_save_analysis/src/lib.rs index 129123349a028..a45406c6b046b 100644 --- a/compiler/rustc_save_analysis/src/lib.rs +++ b/compiler/rustc_save_analysis/src/lib.rs @@ -201,7 +201,7 @@ impl<'tcx> SaveContext<'tcx> { } pub fn get_item_data(&self, item: &hir::Item<'_>) -> Option { - let def_id = self.tcx.hir().local_def_id(item.hir_id).to_def_id(); + let def_id = item.def_id.to_def_id(); match item.kind { hir::ItemKind::Fn(ref sig, ref generics, _) => { let qualname = format!("::{}", self.tcx.def_path_str(def_id)); @@ -290,7 +290,11 @@ impl<'tcx> SaveContext<'tcx> { span: self.span_from_span(item.ident.span), value: filename.to_string(), parent: None, - children: m.item_ids.iter().map(|i| id_from_hir_id(i.id, self)).collect(), + children: m + .item_ids + .iter() + .map(|i| id_from_def_id(i.def_id.to_def_id())) + .collect(), decl_id: None, docs: self.docs_for_attrs(&item.attrs), sig: sig::item_signature(item, self), diff --git a/compiler/rustc_save_analysis/src/sig.rs b/compiler/rustc_save_analysis/src/sig.rs index 6540960cc37d1..a1fee58629a55 100644 --- a/compiler/rustc_save_analysis/src/sig.rs +++ b/compiler/rustc_save_analysis/src/sig.rs @@ -318,7 +318,7 @@ impl<'hir> Sig for hir::Ty<'hir> { } hir::TyKind::OpaqueDef(item_id, _) => { let item = scx.tcx.hir().item(item_id); - item.make(offset, Some(item_id.id), scx) + item.make(offset, Some(item_id.hir_id()), scx) } hir::TyKind::Typeof(_) | hir::TyKind::Infer | hir::TyKind::Err => Err("Ty"), } @@ -327,7 +327,7 @@ impl<'hir> Sig for hir::Ty<'hir> { impl<'hir> Sig for hir::Item<'hir> { fn make(&self, offset: usize, _parent_id: Option, scx: &SaveContext<'_>) -> Result { - let id = Some(self.hir_id); + let id = Some(self.hir_id()); match self.kind { hir::ItemKind::Static(ref ty, m, ref body) => { @@ -337,7 +337,7 @@ impl<'hir> Sig for hir::Item<'hir> { } let name = self.ident.to_string(); let defs = vec![SigElement { - id: id_from_hir_id(self.hir_id, scx), + id: id_from_def_id(self.def_id.to_def_id()), start: offset + text.len(), end: offset + text.len() + name.len(), }]; @@ -359,7 +359,7 @@ impl<'hir> Sig for hir::Item<'hir> { let mut text = "const ".to_owned(); let name = self.ident.to_string(); let defs = vec![SigElement { - id: id_from_hir_id(self.hir_id, scx), + id: id_from_def_id(self.def_id.to_def_id()), start: offset + text.len(), end: offset + text.len() + name.len(), }]; @@ -391,7 +391,7 @@ impl<'hir> Sig for hir::Item<'hir> { text.push_str("fn "); let mut sig = - name_and_generics(text, offset, generics, self.hir_id, self.ident, scx)?; + name_and_generics(text, offset, generics, self.hir_id(), self.ident, scx)?; sig.text.push('('); for i in decl.inputs { @@ -420,7 +420,7 @@ impl<'hir> Sig for hir::Item<'hir> { let mut text = "mod ".to_owned(); let name = self.ident.to_string(); let defs = vec![SigElement { - id: id_from_hir_id(self.hir_id, scx), + id: id_from_def_id(self.def_id.to_def_id()), start: offset + text.len(), end: offset + text.len() + name.len(), }]; @@ -433,7 +433,7 @@ impl<'hir> Sig for hir::Item<'hir> { hir::ItemKind::TyAlias(ref ty, ref generics) => { let text = "type ".to_owned(); let mut sig = - name_and_generics(text, offset, generics, self.hir_id, self.ident, scx)?; + name_and_generics(text, offset, generics, self.hir_id(), self.ident, scx)?; sig.text.push_str(" = "); let ty = ty.make(offset + sig.text.len(), id, scx)?; @@ -445,21 +445,21 @@ impl<'hir> Sig for hir::Item<'hir> { hir::ItemKind::Enum(_, ref generics) => { let text = "enum ".to_owned(); let mut sig = - name_and_generics(text, offset, generics, self.hir_id, self.ident, scx)?; + name_and_generics(text, offset, generics, self.hir_id(), self.ident, scx)?; sig.text.push_str(" {}"); Ok(sig) } hir::ItemKind::Struct(_, ref generics) => { let text = "struct ".to_owned(); let mut sig = - name_and_generics(text, offset, generics, self.hir_id, self.ident, scx)?; + name_and_generics(text, offset, generics, self.hir_id(), self.ident, scx)?; sig.text.push_str(" {}"); Ok(sig) } hir::ItemKind::Union(_, ref generics) => { let text = "union ".to_owned(); let mut sig = - name_and_generics(text, offset, generics, self.hir_id, self.ident, scx)?; + name_and_generics(text, offset, generics, self.hir_id(), self.ident, scx)?; sig.text.push_str(" {}"); Ok(sig) } @@ -475,7 +475,7 @@ impl<'hir> Sig for hir::Item<'hir> { } text.push_str("trait "); let mut sig = - name_and_generics(text, offset, generics, self.hir_id, self.ident, scx)?; + name_and_generics(text, offset, generics, self.hir_id(), self.ident, scx)?; if !bounds.is_empty() { sig.text.push_str(": "); @@ -490,7 +490,7 @@ impl<'hir> Sig for hir::Item<'hir> { let mut text = String::new(); text.push_str("trait "); let mut sig = - name_and_generics(text, offset, generics, self.hir_id, self.ident, scx)?; + name_and_generics(text, offset, generics, self.hir_id(), self.ident, scx)?; if !bounds.is_empty() { sig.text.push_str(" = "); diff --git a/compiler/rustc_span/src/def_id.rs b/compiler/rustc_span/src/def_id.rs index b24ede9c53aed..70e9526f626da 100644 --- a/compiler/rustc_span/src/def_id.rs +++ b/compiler/rustc_span/src/def_id.rs @@ -227,6 +227,8 @@ pub struct LocalDefId { pub local_def_index: DefIndex, } +pub const CRATE_DEF_ID: LocalDefId = LocalDefId { local_def_index: CRATE_DEF_INDEX }; + impl Idx for LocalDefId { #[inline] fn new(idx: usize) -> Self { @@ -268,6 +270,8 @@ impl Decodable for LocalDefId { } } +rustc_data_structures::define_id_collections!(LocalDefIdMap, LocalDefIdSet, LocalDefId); + impl HashStable for DefId { fn hash_stable(&self, hcx: &mut CTX, hasher: &mut StableHasher) { hcx.hash_def_id(*self, hasher) diff --git a/compiler/rustc_symbol_mangling/src/test.rs b/compiler/rustc_symbol_mangling/src/test.rs index 8c5e438a7284b..1a3b89302bb43 100644 --- a/compiler/rustc_symbol_mangling/src/test.rs +++ b/compiler/rustc_symbol_mangling/src/test.rs @@ -61,7 +61,7 @@ impl SymbolNamesTest<'tcx> { impl hir::itemlikevisit::ItemLikeVisitor<'tcx> for SymbolNamesTest<'tcx> { fn visit_item(&mut self, item: &'tcx hir::Item<'tcx>) { - self.process_attrs(item.hir_id); + self.process_attrs(item.hir_id()); } fn visit_trait_item(&mut self, trait_item: &'tcx hir::TraitItem<'tcx>) { diff --git a/compiler/rustc_typeck/src/astconv/mod.rs b/compiler/rustc_typeck/src/astconv/mod.rs index 3dbc71588fe37..75341a51ba4bf 100644 --- a/compiler/rustc_typeck/src/astconv/mod.rs +++ b/compiler/rustc_typeck/src/astconv/mod.rs @@ -2211,7 +2211,7 @@ impl<'o, 'tcx> dyn AstConv<'tcx> + 'o { } hir::TyKind::OpaqueDef(item_id, ref lifetimes) => { let opaque_ty = tcx.hir().item(item_id); - let def_id = tcx.hir().local_def_id(item_id.id).to_def_id(); + let def_id = item_id.def_id.to_def_id(); match opaque_ty.kind { hir::ItemKind::OpaqueTy(hir::OpaqueTy { impl_trait_fn, .. }) => { diff --git a/compiler/rustc_typeck/src/check/check.rs b/compiler/rustc_typeck/src/check/check.rs index 012ccb1af46b1..99afaf3466210 100644 --- a/compiler/rustc_typeck/src/check/check.rs +++ b/compiler/rustc_typeck/src/check/check.rs @@ -373,8 +373,7 @@ pub(super) fn check_fn<'a, 'tcx>( (fcx, gen_ty) } -pub(super) fn check_struct(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) { - let def_id = tcx.hir().local_def_id(id); +fn check_struct(tcx: TyCtxt<'_>, def_id: LocalDefId, span: Span) { let def = tcx.adt_def(def_id); def.destructor(tcx); // force the destructor to be evaluated check_representable(tcx, span, def_id); @@ -387,8 +386,7 @@ pub(super) fn check_struct(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) { check_packed(tcx, span, def); } -fn check_union(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) { - let def_id = tcx.hir().local_def_id(id); +fn check_union(tcx: TyCtxt<'_>, def_id: LocalDefId, span: Span) { let def = tcx.adt_def(def_id); def.destructor(tcx); // force the destructor to be evaluated check_representable(tcx, span, def_id); @@ -683,34 +681,32 @@ fn check_opaque_meets_bounds<'tcx>( pub fn check_item_type<'tcx>(tcx: TyCtxt<'tcx>, it: &'tcx hir::Item<'tcx>) { debug!( - "check_item_type(it.hir_id={}, it.name={})", - it.hir_id, - tcx.def_path_str(tcx.hir().local_def_id(it.hir_id).to_def_id()) + "check_item_type(it.def_id={:?}, it.name={})", + it.def_id, + tcx.def_path_str(it.def_id.to_def_id()) ); let _indenter = indenter(); match it.kind { // Consts can play a role in type-checking, so they are included here. hir::ItemKind::Static(..) => { - let def_id = tcx.hir().local_def_id(it.hir_id); - tcx.ensure().typeck(def_id); - maybe_check_static_with_link_section(tcx, def_id, it.span); - check_static_inhabited(tcx, def_id, it.span); + tcx.ensure().typeck(it.def_id); + maybe_check_static_with_link_section(tcx, it.def_id, it.span); + check_static_inhabited(tcx, it.def_id, it.span); } hir::ItemKind::Const(..) => { - tcx.ensure().typeck(tcx.hir().local_def_id(it.hir_id)); + tcx.ensure().typeck(it.def_id); } hir::ItemKind::Enum(ref enum_definition, _) => { - check_enum(tcx, it.span, &enum_definition.variants, it.hir_id); + check_enum(tcx, it.span, &enum_definition.variants, it.def_id); } hir::ItemKind::Fn(..) => {} // entirely within check_item_body hir::ItemKind::Impl(ref impl_) => { - debug!("ItemKind::Impl {} with id {}", it.ident, it.hir_id); - let impl_def_id = tcx.hir().local_def_id(it.hir_id); - if let Some(impl_trait_ref) = tcx.impl_trait_ref(impl_def_id) { + debug!("ItemKind::Impl {} with id {:?}", it.ident, it.def_id); + if let Some(impl_trait_ref) = tcx.impl_trait_ref(it.def_id) { check_impl_items_against_trait( tcx, it.span, - impl_def_id, + it.def_id, impl_trait_ref, &impl_.items, ); @@ -719,8 +715,7 @@ pub fn check_item_type<'tcx>(tcx: TyCtxt<'tcx>, it: &'tcx hir::Item<'tcx>) { } } hir::ItemKind::Trait(_, _, _, _, ref items) => { - let def_id = tcx.hir().local_def_id(it.hir_id); - check_on_unimplemented(tcx, def_id.to_def_id(), it); + check_on_unimplemented(tcx, it.def_id.to_def_id(), it); for item in items.iter() { let item = tcx.hir().trait_item(item.id); @@ -733,13 +728,13 @@ pub fn check_item_type<'tcx>(tcx: TyCtxt<'tcx>, it: &'tcx hir::Item<'tcx>) { let item_def_id = tcx.hir().local_def_id(item.hir_id).to_def_id(); let assoc_item = tcx.associated_item(item_def_id); let trait_substs = - InternalSubsts::identity_for_item(tcx, def_id.to_def_id()); + InternalSubsts::identity_for_item(tcx, it.def_id.to_def_id()); let _: Result<_, rustc_errors::ErrorReported> = check_type_bounds( tcx, assoc_item, assoc_item, item.span, - ty::TraitRef { def_id: def_id.to_def_id(), substs: trait_substs }, + ty::TraitRef { def_id: it.def_id.to_def_id(), substs: trait_substs }, ); } _ => {} @@ -747,10 +742,10 @@ pub fn check_item_type<'tcx>(tcx: TyCtxt<'tcx>, it: &'tcx hir::Item<'tcx>) { } } hir::ItemKind::Struct(..) => { - check_struct(tcx, it.hir_id, it.span); + check_struct(tcx, it.def_id, it.span); } hir::ItemKind::Union(..) => { - check_union(tcx, it.hir_id, it.span); + check_union(tcx, it.def_id, it.span); } hir::ItemKind::OpaqueTy(hir::OpaqueTy { origin, .. }) => { // HACK(jynelson): trying to infer the type of `impl trait` breaks documenting @@ -758,16 +753,13 @@ pub fn check_item_type<'tcx>(tcx: TyCtxt<'tcx>, it: &'tcx hir::Item<'tcx>) { // Since rustdoc doesn't care about the concrete type behind `impl Trait`, just don't look at it! // See https://github.com/rust-lang/rust/issues/75100 if !tcx.sess.opts.actually_rustdoc { - let def_id = tcx.hir().local_def_id(it.hir_id); - - let substs = InternalSubsts::identity_for_item(tcx, def_id.to_def_id()); - check_opaque(tcx, def_id, substs, it.span, &origin); + let substs = InternalSubsts::identity_for_item(tcx, it.def_id.to_def_id()); + check_opaque(tcx, it.def_id, substs, it.span, &origin); } } hir::ItemKind::TyAlias(..) => { - let def_id = tcx.hir().local_def_id(it.hir_id); - let pty_ty = tcx.type_of(def_id); - let generics = tcx.generics_of(def_id); + let pty_ty = tcx.type_of(it.def_id); + let generics = tcx.generics_of(it.def_id); check_type_params_are_used(tcx, &generics, pty_ty); } hir::ItemKind::ForeignMod { abi, items } => { @@ -835,9 +827,8 @@ pub fn check_item_type<'tcx>(tcx: TyCtxt<'tcx>, it: &'tcx hir::Item<'tcx>) { } pub(super) fn check_on_unimplemented(tcx: TyCtxt<'_>, trait_def_id: DefId, item: &hir::Item<'_>) { - let item_def_id = tcx.hir().local_def_id(item.hir_id); // an error would be reported if this fails. - let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item_def_id.to_def_id()); + let _ = traits::OnUnimplementedDirective::of_item(tcx, trait_def_id, item.def_id.to_def_id()); } pub(super) fn check_specialization_validity<'tcx>( @@ -1345,13 +1336,12 @@ pub(super) fn check_transparent<'tcx>(tcx: TyCtxt<'tcx>, sp: Span, adt: &'tcx ty } #[allow(trivial_numeric_casts)] -pub fn check_enum<'tcx>( +fn check_enum<'tcx>( tcx: TyCtxt<'tcx>, sp: Span, vs: &'tcx [hir::Variant<'tcx>], - id: hir::HirId, + def_id: LocalDefId, ) { - let def_id = tcx.hir().local_def_id(id); let def = tcx.adt_def(def_id); def.destructor(tcx); // force the destructor to be evaluated diff --git a/compiler/rustc_typeck/src/check/method/suggest.rs b/compiler/rustc_typeck/src/check/method/suggest.rs index 5c09885b63180..112e7e3ac9f36 100644 --- a/compiler/rustc_typeck/src/check/method/suggest.rs +++ b/compiler/rustc_typeck/src/check/method/suggest.rs @@ -11,7 +11,6 @@ use rustc_hir::intravisit; use rustc_hir::lang_items::LangItem; use rustc_hir::{ExprKind, Node, QPath}; use rustc_infer::infer::type_variable::{TypeVariableOrigin, TypeVariableOriginKind}; -use rustc_middle::hir::map as hir_map; use rustc_middle::ty::fast_reject::simplify_type; use rustc_middle::ty::print::with_crate_prefix; use rustc_middle::ty::{ @@ -1352,17 +1351,15 @@ fn compute_all_traits(tcx: TyCtxt<'_>) -> Vec { // Crate-local: - struct Visitor<'a, 'tcx> { - map: &'a hir_map::Map<'tcx>, + struct Visitor<'a> { traits: &'a mut Vec, } - impl<'v, 'a, 'tcx> itemlikevisit::ItemLikeVisitor<'v> for Visitor<'a, 'tcx> { + impl<'v, 'a> itemlikevisit::ItemLikeVisitor<'v> for Visitor<'a> { fn visit_item(&mut self, i: &'v hir::Item<'v>) { match i.kind { hir::ItemKind::Trait(..) | hir::ItemKind::TraitAlias(..) => { - let def_id = self.map.local_def_id(i.hir_id); - self.traits.push(def_id.to_def_id()); + self.traits.push(i.def_id.to_def_id()); } _ => (), } @@ -1375,7 +1372,7 @@ fn compute_all_traits(tcx: TyCtxt<'_>) -> Vec { fn visit_foreign_item(&mut self, _foreign_item: &hir::ForeignItem<'_>) {} } - tcx.hir().krate().visit_all_item_likes(&mut Visitor { map: &tcx.hir(), traits: &mut traits }); + tcx.hir().krate().visit_all_item_likes(&mut Visitor { traits: &mut traits }); // Cross-crate: diff --git a/compiler/rustc_typeck/src/check/wfcheck.rs b/compiler/rustc_typeck/src/check/wfcheck.rs index c90db4786e35f..fbb5b2d42e939 100644 --- a/compiler/rustc_typeck/src/check/wfcheck.rs +++ b/compiler/rustc_typeck/src/check/wfcheck.rs @@ -80,8 +80,8 @@ pub fn check_item_well_formed(tcx: TyCtxt<'_>, def_id: LocalDefId) { let item = tcx.hir().expect_item(hir_id); debug!( - "check_item_well_formed(it.hir_id={:?}, it.name={})", - item.hir_id, + "check_item_well_formed(it.def_id={:?}, it.name={})", + item.def_id, tcx.def_path_str(def_id.to_def_id()) ); @@ -105,7 +105,7 @@ pub fn check_item_well_formed(tcx: TyCtxt<'_>, def_id: LocalDefId) { // for `T` hir::ItemKind::Impl(ref impl_) => { let is_auto = tcx - .impl_trait_ref(tcx.hir().local_def_id(item.hir_id)) + .impl_trait_ref(item.def_id) .map_or(false, |trait_ref| tcx.trait_is_auto(trait_ref.def_id)); if let (hir::Defaultness::Default { .. }, true) = (impl_.defaultness, is_auto) { let sp = impl_.of_trait.as_ref().map_or(item.span, |t| t.path.span); @@ -141,13 +141,13 @@ pub fn check_item_well_formed(tcx: TyCtxt<'_>, def_id: LocalDefId) { } } hir::ItemKind::Fn(ref sig, ..) => { - check_item_fn(tcx, item.hir_id, item.ident, item.span, sig.decl); + check_item_fn(tcx, item.hir_id(), item.ident, item.span, sig.decl); } hir::ItemKind::Static(ref ty, ..) => { - check_item_type(tcx, item.hir_id, ty.span, false); + check_item_type(tcx, item.hir_id(), ty.span, false); } hir::ItemKind::Const(ref ty, ..) => { - check_item_type(tcx, item.hir_id, ty.span, false); + check_item_type(tcx, item.hir_id(), ty.span, false); } hir::ItemKind::ForeignMod { items, .. } => { for it in items.iter() { @@ -215,7 +215,7 @@ fn could_be_self(trait_def_id: LocalDefId, ty: &hir::Ty<'_>) -> bool { fn check_object_unsafe_self_trait_by_name(tcx: TyCtxt<'_>, item: &hir::TraitItem<'_>) { let (trait_name, trait_def_id) = match tcx.hir().get(tcx.hir().get_parent_item(item.hir_id)) { hir::Node::Item(item) => match item.kind { - hir::ItemKind::Trait(..) => (item.ident, tcx.hir().local_def_id(item.hir_id)), + hir::ItemKind::Trait(..) => (item.ident, item.def_id), _ => return, }, _ => return, @@ -432,7 +432,7 @@ fn check_associated_item( } fn for_item<'tcx>(tcx: TyCtxt<'tcx>, item: &hir::Item<'_>) -> CheckWfFcxBuilder<'tcx> { - for_id(tcx, item.hir_id, item.span) + for_id(tcx, item.hir_id(), item.span) } fn for_id(tcx: TyCtxt<'_>, id: hir::HirId, span: Span) -> CheckWfFcxBuilder<'_> { @@ -465,8 +465,7 @@ fn check_type_defn<'tcx, F>( { for_item(tcx, item).with_fcx(|fcx, fcx_tcx| { let variants = lookup_fields(fcx); - let def_id = fcx.tcx.hir().local_def_id(item.hir_id); - let packed = fcx.tcx.adt_def(def_id).repr.packed(); + let packed = fcx.tcx.adt_def(item.def_id).repr.packed(); for variant in &variants { // For DST, or when drop needs to copy things around, all @@ -482,7 +481,7 @@ fn check_type_defn<'tcx, F>( // Just treat unresolved type expression as if it needs drop. true } else { - ty.needs_drop(fcx_tcx, fcx_tcx.param_env(def_id)) + ty.needs_drop(fcx_tcx, fcx_tcx.param_env(item.def_id)) } } }; @@ -541,7 +540,7 @@ fn check_type_defn<'tcx, F>( } } - check_where_clauses(tcx, fcx, item.span, def_id.to_def_id(), None); + check_where_clauses(tcx, fcx, item.span, item.def_id.to_def_id(), None); // No implied bounds in a struct definition. vec![] @@ -549,15 +548,13 @@ fn check_type_defn<'tcx, F>( } fn check_trait(tcx: TyCtxt<'_>, item: &hir::Item<'_>) { - debug!("check_trait: {:?}", item.hir_id); + debug!("check_trait: {:?}", item.def_id); - let trait_def_id = tcx.hir().local_def_id(item.hir_id); - - let trait_def = tcx.trait_def(trait_def_id); + let trait_def = tcx.trait_def(item.def_id); if trait_def.is_marker || matches!(trait_def.specialization_kind, TraitSpecializationKind::Marker) { - for associated_def_id in &*tcx.associated_item_def_ids(trait_def_id) { + for associated_def_id in &*tcx.associated_item_def_ids(item.def_id) { struct_span_err!( tcx.sess, tcx.def_span(*associated_def_id), @@ -569,7 +566,7 @@ fn check_trait(tcx: TyCtxt<'_>, item: &hir::Item<'_>) { } for_item(tcx, item).with_fcx(|fcx, _| { - check_where_clauses(tcx, fcx, item.span, trait_def_id.to_def_id(), None); + check_where_clauses(tcx, fcx, item.span, item.def_id.to_def_id(), None); vec![] }); @@ -665,14 +662,12 @@ fn check_impl<'tcx>( debug!("check_impl: {:?}", item); for_item(tcx, item).with_fcx(|fcx, tcx| { - let item_def_id = fcx.tcx.hir().local_def_id(item.hir_id); - match *ast_trait_ref { Some(ref ast_trait_ref) => { // `#[rustc_reservation_impl]` impls are not real impls and // therefore don't need to be WF (the trait's `Self: Trait` predicate // won't hold). - let trait_ref = fcx.tcx.impl_trait_ref(item_def_id).unwrap(); + let trait_ref = fcx.tcx.impl_trait_ref(item.def_id).unwrap(); let trait_ref = fcx.normalize_associated_types_in(ast_trait_ref.path.span, trait_ref); let obligations = traits::wf::trait_obligations( @@ -688,7 +683,7 @@ fn check_impl<'tcx>( } } None => { - let self_ty = fcx.tcx.type_of(item_def_id); + let self_ty = fcx.tcx.type_of(item.def_id); let self_ty = fcx.normalize_associated_types_in(item.span, self_ty); fcx.register_wf_obligation( self_ty.into(), @@ -698,9 +693,9 @@ fn check_impl<'tcx>( } } - check_where_clauses(tcx, fcx, item.span, item_def_id.to_def_id(), None); + check_where_clauses(tcx, fcx, item.span, item.def_id.to_def_id(), None); - fcx.impl_implied_bounds(item_def_id.to_def_id(), item.span) + fcx.impl_implied_bounds(item.def_id.to_def_id(), item.span) }); } @@ -1238,15 +1233,14 @@ fn check_variances_for_type_defn<'tcx>( item: &hir::Item<'tcx>, hir_generics: &hir::Generics<'_>, ) { - let item_def_id = tcx.hir().local_def_id(item.hir_id); - let ty = tcx.type_of(item_def_id); + let ty = tcx.type_of(item.def_id); if tcx.has_error_field(ty) { return; } - let ty_predicates = tcx.predicates_of(item_def_id); + let ty_predicates = tcx.predicates_of(item.def_id); assert_eq!(ty_predicates.parent, None); - let variances = tcx.variances_of(item_def_id); + let variances = tcx.variances_of(item.def_id); let mut constrained_parameters: FxHashSet<_> = variances .iter() @@ -1354,8 +1348,7 @@ impl Visitor<'tcx> for CheckTypeWellFormedVisitor<'tcx> { fn visit_item(&mut self, i: &'tcx hir::Item<'tcx>) { debug!("visit_item: {:?}", i); - let def_id = self.tcx.hir().local_def_id(i.hir_id); - self.tcx.ensure().check_item_well_formed(def_id); + self.tcx.ensure().check_item_well_formed(i.def_id); hir_visit::walk_item(self, i); } diff --git a/compiler/rustc_typeck/src/check_unused.rs b/compiler/rustc_typeck/src/check_unused.rs index 31121ece898aa..e1743a5dfc1ce 100644 --- a/compiler/rustc_typeck/src/check_unused.rs +++ b/compiler/rustc_typeck/src/check_unused.rs @@ -28,7 +28,7 @@ impl ItemLikeVisitor<'v> for CheckVisitor<'tcx> { return; } if let hir::ItemKind::Use(ref path, _) = item.kind { - self.check_import(item.hir_id, path.span); + self.check_import(item.item_id(), path.span); } } @@ -45,24 +45,28 @@ struct CheckVisitor<'tcx> { } impl CheckVisitor<'tcx> { - fn check_import(&self, id: hir::HirId, span: Span) { - let def_id = self.tcx.hir().local_def_id(id); - if !self.tcx.maybe_unused_trait_import(def_id) { + fn check_import(&self, item_id: hir::ItemId, span: Span) { + if !self.tcx.maybe_unused_trait_import(item_id.def_id) { return; } - if self.used_trait_imports.contains(&def_id) { + if self.used_trait_imports.contains(&item_id.def_id) { return; } - self.tcx.struct_span_lint_hir(lint::builtin::UNUSED_IMPORTS, id, span, |lint| { - let msg = if let Ok(snippet) = self.tcx.sess.source_map().span_to_snippet(span) { - format!("unused import: `{}`", snippet) - } else { - "unused import".to_owned() - }; - lint.build(&msg).emit(); - }); + self.tcx.struct_span_lint_hir( + lint::builtin::UNUSED_IMPORTS, + item_id.hir_id(), + span, + |lint| { + let msg = if let Ok(snippet) = self.tcx.sess.source_map().span_to_snippet(span) { + format!("unused import: `{}`", snippet) + } else { + "unused import".to_owned() + }; + lint.build(&msg).emit(); + }, + ); } } @@ -109,7 +113,6 @@ fn unused_crates_lint(tcx: TyCtxt<'_>) { // Collect all the extern crates (in a reliable order). let mut crates_to_lint = vec![]; tcx.hir().krate().visit_all_item_likes(&mut CollectExternCrateVisitor { - tcx, crates_to_lint: &mut crates_to_lint, }); @@ -189,8 +192,7 @@ fn unused_crates_lint(tcx: TyCtxt<'_>) { } } -struct CollectExternCrateVisitor<'a, 'tcx> { - tcx: TyCtxt<'tcx>, +struct CollectExternCrateVisitor<'a> { crates_to_lint: &'a mut Vec, } @@ -211,12 +213,11 @@ struct ExternCrateToLint { warn_if_unused: bool, } -impl<'a, 'tcx, 'v> ItemLikeVisitor<'v> for CollectExternCrateVisitor<'a, 'tcx> { +impl<'a, 'v> ItemLikeVisitor<'v> for CollectExternCrateVisitor<'a> { fn visit_item(&mut self, item: &hir::Item<'_>) { if let hir::ItemKind::ExternCrate(orig_name) = item.kind { - let extern_crate_def_id = self.tcx.hir().local_def_id(item.hir_id); self.crates_to_lint.push(ExternCrateToLint { - def_id: extern_crate_def_id.to_def_id(), + def_id: item.def_id.to_def_id(), span: item.span, orig_name, warn_if_unused: !item.ident.as_str().starts_with('_'), diff --git a/compiler/rustc_typeck/src/coherence/inherent_impls.rs b/compiler/rustc_typeck/src/coherence/inherent_impls.rs index 8a500852a0326..cc592c7a260f1 100644 --- a/compiler/rustc_typeck/src/coherence/inherent_impls.rs +++ b/compiler/rustc_typeck/src/coherence/inherent_impls.rs @@ -50,8 +50,7 @@ impl ItemLikeVisitor<'v> for InherentCollect<'tcx> { _ => return, }; - let def_id = self.tcx.hir().local_def_id(item.hir_id); - let self_ty = self.tcx.type_of(def_id); + let self_ty = self.tcx.type_of(item.def_id); let lang_items = self.tcx.lang_items(); match *self_ty.kind() { ty::Adt(def, _) => { @@ -65,7 +64,7 @@ impl ItemLikeVisitor<'v> for InherentCollect<'tcx> { } ty::Bool => { self.check_primitive_impl( - def_id, + item.def_id, lang_items.bool_impl(), None, "bool", @@ -76,7 +75,7 @@ impl ItemLikeVisitor<'v> for InherentCollect<'tcx> { } ty::Char => { self.check_primitive_impl( - def_id, + item.def_id, lang_items.char_impl(), None, "char", @@ -87,7 +86,7 @@ impl ItemLikeVisitor<'v> for InherentCollect<'tcx> { } ty::Str => { self.check_primitive_impl( - def_id, + item.def_id, lang_items.str_impl(), lang_items.str_alloc_impl(), "str", @@ -98,7 +97,7 @@ impl ItemLikeVisitor<'v> for InherentCollect<'tcx> { } ty::Slice(slice_item) if slice_item == self.tcx.types.u8 => { self.check_primitive_impl( - def_id, + item.def_id, lang_items.slice_u8_impl(), lang_items.slice_u8_alloc_impl(), "slice_u8", @@ -109,7 +108,7 @@ impl ItemLikeVisitor<'v> for InherentCollect<'tcx> { } ty::Slice(_) => { self.check_primitive_impl( - def_id, + item.def_id, lang_items.slice_impl(), lang_items.slice_alloc_impl(), "slice", @@ -120,7 +119,7 @@ impl ItemLikeVisitor<'v> for InherentCollect<'tcx> { } ty::Array(_, _) => { self.check_primitive_impl( - def_id, + item.def_id, lang_items.array_impl(), None, "array", @@ -133,7 +132,7 @@ impl ItemLikeVisitor<'v> for InherentCollect<'tcx> { if matches!(inner.kind(), ty::Slice(_)) => { self.check_primitive_impl( - def_id, + item.def_id, lang_items.const_slice_ptr_impl(), None, "const_slice_ptr", @@ -146,7 +145,7 @@ impl ItemLikeVisitor<'v> for InherentCollect<'tcx> { if matches!(inner.kind(), ty::Slice(_)) => { self.check_primitive_impl( - def_id, + item.def_id, lang_items.mut_slice_ptr_impl(), None, "mut_slice_ptr", @@ -157,7 +156,7 @@ impl ItemLikeVisitor<'v> for InherentCollect<'tcx> { } ty::RawPtr(ty::TypeAndMut { ty: _, mutbl: hir::Mutability::Not }) => { self.check_primitive_impl( - def_id, + item.def_id, lang_items.const_ptr_impl(), None, "const_ptr", @@ -168,7 +167,7 @@ impl ItemLikeVisitor<'v> for InherentCollect<'tcx> { } ty::RawPtr(ty::TypeAndMut { ty: _, mutbl: hir::Mutability::Mut }) => { self.check_primitive_impl( - def_id, + item.def_id, lang_items.mut_ptr_impl(), None, "mut_ptr", @@ -179,7 +178,7 @@ impl ItemLikeVisitor<'v> for InherentCollect<'tcx> { } ty::Int(ty::IntTy::I8) => { self.check_primitive_impl( - def_id, + item.def_id, lang_items.i8_impl(), None, "i8", @@ -190,7 +189,7 @@ impl ItemLikeVisitor<'v> for InherentCollect<'tcx> { } ty::Int(ty::IntTy::I16) => { self.check_primitive_impl( - def_id, + item.def_id, lang_items.i16_impl(), None, "i16", @@ -201,7 +200,7 @@ impl ItemLikeVisitor<'v> for InherentCollect<'tcx> { } ty::Int(ty::IntTy::I32) => { self.check_primitive_impl( - def_id, + item.def_id, lang_items.i32_impl(), None, "i32", @@ -212,7 +211,7 @@ impl ItemLikeVisitor<'v> for InherentCollect<'tcx> { } ty::Int(ty::IntTy::I64) => { self.check_primitive_impl( - def_id, + item.def_id, lang_items.i64_impl(), None, "i64", @@ -223,7 +222,7 @@ impl ItemLikeVisitor<'v> for InherentCollect<'tcx> { } ty::Int(ty::IntTy::I128) => { self.check_primitive_impl( - def_id, + item.def_id, lang_items.i128_impl(), None, "i128", @@ -234,7 +233,7 @@ impl ItemLikeVisitor<'v> for InherentCollect<'tcx> { } ty::Int(ty::IntTy::Isize) => { self.check_primitive_impl( - def_id, + item.def_id, lang_items.isize_impl(), None, "isize", @@ -245,7 +244,7 @@ impl ItemLikeVisitor<'v> for InherentCollect<'tcx> { } ty::Uint(ty::UintTy::U8) => { self.check_primitive_impl( - def_id, + item.def_id, lang_items.u8_impl(), None, "u8", @@ -256,7 +255,7 @@ impl ItemLikeVisitor<'v> for InherentCollect<'tcx> { } ty::Uint(ty::UintTy::U16) => { self.check_primitive_impl( - def_id, + item.def_id, lang_items.u16_impl(), None, "u16", @@ -267,7 +266,7 @@ impl ItemLikeVisitor<'v> for InherentCollect<'tcx> { } ty::Uint(ty::UintTy::U32) => { self.check_primitive_impl( - def_id, + item.def_id, lang_items.u32_impl(), None, "u32", @@ -278,7 +277,7 @@ impl ItemLikeVisitor<'v> for InherentCollect<'tcx> { } ty::Uint(ty::UintTy::U64) => { self.check_primitive_impl( - def_id, + item.def_id, lang_items.u64_impl(), None, "u64", @@ -289,7 +288,7 @@ impl ItemLikeVisitor<'v> for InherentCollect<'tcx> { } ty::Uint(ty::UintTy::U128) => { self.check_primitive_impl( - def_id, + item.def_id, lang_items.u128_impl(), None, "u128", @@ -300,7 +299,7 @@ impl ItemLikeVisitor<'v> for InherentCollect<'tcx> { } ty::Uint(ty::UintTy::Usize) => { self.check_primitive_impl( - def_id, + item.def_id, lang_items.usize_impl(), None, "usize", @@ -311,7 +310,7 @@ impl ItemLikeVisitor<'v> for InherentCollect<'tcx> { } ty::Float(ty::FloatTy::F32) => { self.check_primitive_impl( - def_id, + item.def_id, lang_items.f32_impl(), lang_items.f32_runtime_impl(), "f32", @@ -322,7 +321,7 @@ impl ItemLikeVisitor<'v> for InherentCollect<'tcx> { } ty::Float(ty::FloatTy::F64) => { self.check_primitive_impl( - def_id, + item.def_id, lang_items.f64_impl(), lang_items.f64_runtime_impl(), "f64", @@ -369,9 +368,8 @@ impl InherentCollect<'tcx> { // Add the implementation to the mapping from implementation to base // type def ID, if there is a base type for this implementation and // the implementation does not have any associated traits. - let impl_def_id = self.tcx.hir().local_def_id(item.hir_id); let vec = self.impls_map.inherent_impls.entry(def_id).or_default(); - vec.push(impl_def_id.to_def_id()); + vec.push(item.def_id.to_def_id()); } else { struct_span_err!( self.tcx.sess, diff --git a/compiler/rustc_typeck/src/coherence/inherent_impls_overlap.rs b/compiler/rustc_typeck/src/coherence/inherent_impls_overlap.rs index 50d8867432817..2965409999202 100644 --- a/compiler/rustc_typeck/src/coherence/inherent_impls_overlap.rs +++ b/compiler/rustc_typeck/src/coherence/inherent_impls_overlap.rs @@ -123,8 +123,7 @@ impl ItemLikeVisitor<'v> for InherentOverlapChecker<'tcx> { | hir::ItemKind::Struct(..) | hir::ItemKind::Trait(..) | hir::ItemKind::Union(..) => { - let ty_def_id = self.tcx.hir().local_def_id(item.hir_id); - let impls = self.tcx.inherent_impls(ty_def_id); + let impls = self.tcx.inherent_impls(item.def_id); // If there is only one inherent impl block, // there is nothing to overlap check it with diff --git a/compiler/rustc_typeck/src/coherence/orphan.rs b/compiler/rustc_typeck/src/coherence/orphan.rs index 9333aac6018fe..05932427bcf7a 100644 --- a/compiler/rustc_typeck/src/coherence/orphan.rs +++ b/compiler/rustc_typeck/src/coherence/orphan.rs @@ -24,7 +24,6 @@ impl ItemLikeVisitor<'v> for OrphanChecker<'tcx> { /// to prevent inundating the user with a bunch of similar error /// reports. fn visit_item(&mut self, item: &hir::Item<'_>) { - let def_id = self.tcx.hir().local_def_id(item.hir_id); // "Trait" impl if let hir::ItemKind::Impl(hir::Impl { generics, of_trait: Some(ref tr), self_ty, .. @@ -32,13 +31,13 @@ impl ItemLikeVisitor<'v> for OrphanChecker<'tcx> { { debug!( "coherence2::orphan check: trait impl {}", - self.tcx.hir().node_to_string(item.hir_id) + self.tcx.hir().node_to_string(item.hir_id()) ); - let trait_ref = self.tcx.impl_trait_ref(def_id).unwrap(); + let trait_ref = self.tcx.impl_trait_ref(item.def_id).unwrap(); let trait_def_id = trait_ref.def_id; let sm = self.tcx.sess.source_map(); let sp = sm.guess_head_span(item.span); - match traits::orphan_check(self.tcx, def_id.to_def_id()) { + match traits::orphan_check(self.tcx, item.def_id.to_def_id()) { Ok(()) => {} Err(traits::OrphanCheckErr::NonLocalInputType(tys)) => { let mut err = struct_span_err!( diff --git a/compiler/rustc_typeck/src/coherence/unsafety.rs b/compiler/rustc_typeck/src/coherence/unsafety.rs index 3a290b7756e13..6b995b9738612 100644 --- a/compiler/rustc_typeck/src/coherence/unsafety.rs +++ b/compiler/rustc_typeck/src/coherence/unsafety.rs @@ -24,8 +24,7 @@ impl UnsafetyChecker<'tcx> { unsafety: hir::Unsafety, polarity: hir::ImplPolarity, ) { - let local_did = self.tcx.hir().local_def_id(item.hir_id); - if let Some(trait_ref) = self.tcx.impl_trait_ref(local_did) { + if let Some(trait_ref) = self.tcx.impl_trait_ref(item.def_id) { let trait_def = self.tcx.trait_def(trait_ref.def_id); let unsafe_attr = impl_generics.and_then(|generics| { generics.params.iter().find(|p| p.pure_wrt_drop).map(|_| "may_dangle") diff --git a/compiler/rustc_typeck/src/collect.rs b/compiler/rustc_typeck/src/collect.rs index e24aa7d76f194..21c0a2d79c81b 100644 --- a/compiler/rustc_typeck/src/collect.rs +++ b/compiler/rustc_typeck/src/collect.rs @@ -247,7 +247,7 @@ impl Visitor<'tcx> for CollectItemTypesVisitor<'tcx> { } fn visit_item(&mut self, item: &'tcx hir::Item<'tcx>) { - convert_item(self.tcx, item.hir_id); + convert_item(self.tcx, item.item_id()); reject_placeholder_type_signatures_in_item(self.tcx, item); intravisit::walk_item(self, item); } @@ -714,10 +714,10 @@ fn is_param(tcx: TyCtxt<'_>, ast_ty: &hir::Ty<'_>, param_id: hir::HirId) -> bool } } -fn convert_item(tcx: TyCtxt<'_>, item_id: hir::HirId) { - let it = tcx.hir().expect_item(item_id); - debug!("convert: item {} with id {}", it.ident, it.hir_id); - let def_id = tcx.hir().local_def_id(item_id); +fn convert_item(tcx: TyCtxt<'_>, item_id: hir::ItemId) { + let it = tcx.hir().item(item_id); + debug!("convert: item {} with id {}", it.ident, it.hir_id()); + let def_id = item_id.def_id; match it.kind { // These don't define types. @@ -1122,7 +1122,7 @@ fn super_predicates_that_define_assoc_type( let is_trait_alias = tcx.is_trait_alias(trait_def_id); let superbounds2 = icx.type_parameter_bounds_in_generics( generics, - item.hir_id, + item.hir_id(), self_param_ty, OnlySelfBounds(!is_trait_alias), assoc_name, @@ -1446,12 +1446,12 @@ fn generics_of(tcx: TyCtxt<'_>, def_id: DefId) -> ty::Generics { // // Something of a hack: use the node id for the trait, also as // the node id for the Self type parameter. - let param_id = item.hir_id; + let param_id = item.def_id; opt_self = Some(ty::GenericParamDef { index: 0, name: kw::SelfUpper, - def_id: tcx.hir().local_def_id(param_id).to_def_id(), + def_id: param_id.to_def_id(), pure_wrt_drop: false, kind: ty::GenericParamDefKind::Type { has_default: false, diff --git a/compiler/rustc_typeck/src/collect/type_of.rs b/compiler/rustc_typeck/src/collect/type_of.rs index 7fa58dcd5f44f..ca2f6c450ea44 100644 --- a/compiler/rustc_typeck/src/collect/type_of.rs +++ b/compiler/rustc_typeck/src/collect/type_of.rs @@ -582,10 +582,9 @@ fn find_opaque_ty_constraints(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Ty<'_> { } fn visit_item(&mut self, it: &'tcx Item<'tcx>) { debug!("find_existential_constraints: visiting {:?}", it); - let def_id = self.tcx.hir().local_def_id(it.hir_id); // The opaque type itself or its children are not within its reveal scope. - if def_id.to_def_id() != self.def_id { - self.check(def_id); + if it.def_id.to_def_id() != self.def_id { + self.check(it.def_id); intravisit::walk_item(self, it); } } diff --git a/compiler/rustc_typeck/src/impl_wf_check.rs b/compiler/rustc_typeck/src/impl_wf_check.rs index 0bdcbaac0e984..c3606ec564aed 100644 --- a/compiler/rustc_typeck/src/impl_wf_check.rs +++ b/compiler/rustc_typeck/src/impl_wf_check.rs @@ -81,11 +81,10 @@ struct ImplWfCheck<'tcx> { impl ItemLikeVisitor<'tcx> for ImplWfCheck<'tcx> { fn visit_item(&mut self, item: &'tcx hir::Item<'tcx>) { if let hir::ItemKind::Impl(ref impl_) = item.kind { - let impl_def_id = self.tcx.hir().local_def_id(item.hir_id); - enforce_impl_params_are_constrained(self.tcx, impl_def_id, impl_.items); + enforce_impl_params_are_constrained(self.tcx, item.def_id, impl_.items); enforce_impl_items_are_distinct(self.tcx, impl_.items); if self.min_specialization { - check_min_specialization(self.tcx, impl_def_id.to_def_id(), item.span); + check_min_specialization(self.tcx, item.def_id.to_def_id(), item.span); } } } diff --git a/compiler/rustc_typeck/src/outlives/implicit_infer.rs b/compiler/rustc_typeck/src/outlives/implicit_infer.rs index 02008e180b34d..6e6ecf6a22b51 100644 --- a/compiler/rustc_typeck/src/outlives/implicit_infer.rs +++ b/compiler/rustc_typeck/src/outlives/implicit_infer.rs @@ -2,7 +2,6 @@ use rustc_data_structures::fx::FxHashMap; use rustc_hir as hir; use rustc_hir::def_id::DefId; use rustc_hir::itemlikevisit::ItemLikeVisitor; -use rustc_hir::Node; use rustc_middle::ty::subst::{GenericArg, GenericArgKind, Subst}; use rustc_middle::ty::{self, Ty, TyCtxt}; use rustc_span::Span; @@ -53,16 +52,10 @@ pub struct InferVisitor<'cx, 'tcx> { impl<'cx, 'tcx> ItemLikeVisitor<'tcx> for InferVisitor<'cx, 'tcx> { fn visit_item(&mut self, item: &hir::Item<'_>) { - let item_did = self.tcx.hir().local_def_id(item.hir_id); + let item_did = item.def_id; debug!("InferVisitor::visit_item(item={:?})", item_did); - let hir_id = self.tcx.hir().local_def_id_to_hir_id(item_did); - let item = match self.tcx.hir().get(hir_id) { - Node::Item(item) => item, - _ => bug!(), - }; - let mut item_required_predicates = RequiredPredicates::default(); match item.kind { hir::ItemKind::Union(..) | hir::ItemKind::Enum(..) | hir::ItemKind::Struct(..) => { diff --git a/compiler/rustc_typeck/src/outlives/test.rs b/compiler/rustc_typeck/src/outlives/test.rs index 56d42f756c496..d4bef0c409a8f 100644 --- a/compiler/rustc_typeck/src/outlives/test.rs +++ b/compiler/rustc_typeck/src/outlives/test.rs @@ -14,12 +14,10 @@ struct OutlivesTest<'tcx> { impl ItemLikeVisitor<'tcx> for OutlivesTest<'tcx> { fn visit_item(&mut self, item: &'tcx hir::Item<'tcx>) { - let item_def_id = self.tcx.hir().local_def_id(item.hir_id); - // For unit testing: check for a special "rustc_outlives" // attribute and report an error with various results if found. - if self.tcx.has_attr(item_def_id.to_def_id(), sym::rustc_outlives) { - let inferred_outlives_of = self.tcx.inferred_outlives_of(item_def_id); + if self.tcx.has_attr(item.def_id.to_def_id(), sym::rustc_outlives) { + let inferred_outlives_of = self.tcx.inferred_outlives_of(item.def_id); struct_span_err!(self.tcx.sess, item.span, E0640, "{:?}", inferred_outlives_of).emit(); } } diff --git a/compiler/rustc_typeck/src/variance/constraints.rs b/compiler/rustc_typeck/src/variance/constraints.rs index 4e53b8c3615c8..d66508e5b7f19 100644 --- a/compiler/rustc_typeck/src/variance/constraints.rs +++ b/compiler/rustc_typeck/src/variance/constraints.rs @@ -71,7 +71,7 @@ impl<'a, 'tcx, 'v> ItemLikeVisitor<'v> for ConstraintContext<'a, 'tcx> { fn visit_item(&mut self, item: &hir::Item<'_>) { match item.kind { hir::ItemKind::Struct(ref struct_def, _) | hir::ItemKind::Union(ref struct_def, _) => { - self.visit_node_helper(item.hir_id); + self.visit_node_helper(item.hir_id()); if let hir::VariantData::Tuple(..) = *struct_def { self.visit_node_helper(struct_def.ctor_hir_id().unwrap()); @@ -79,7 +79,7 @@ impl<'a, 'tcx, 'v> ItemLikeVisitor<'v> for ConstraintContext<'a, 'tcx> { } hir::ItemKind::Enum(ref enum_def, _) => { - self.visit_node_helper(item.hir_id); + self.visit_node_helper(item.hir_id()); for variant in enum_def.variants { if let hir::VariantData::Tuple(..) = variant.data { @@ -89,7 +89,7 @@ impl<'a, 'tcx, 'v> ItemLikeVisitor<'v> for ConstraintContext<'a, 'tcx> { } hir::ItemKind::Fn(..) => { - self.visit_node_helper(item.hir_id); + self.visit_node_helper(item.hir_id()); } _ => {} diff --git a/compiler/rustc_typeck/src/variance/terms.rs b/compiler/rustc_typeck/src/variance/terms.rs index 3b2a1c24ddd8d..acedce4d2d422 100644 --- a/compiler/rustc_typeck/src/variance/terms.rs +++ b/compiler/rustc_typeck/src/variance/terms.rs @@ -128,11 +128,11 @@ impl<'a, 'tcx> TermsContext<'a, 'tcx> { impl<'a, 'tcx, 'v> ItemLikeVisitor<'v> for TermsContext<'a, 'tcx> { fn visit_item(&mut self, item: &hir::Item<'_>) { - debug!("add_inferreds for item {}", self.tcx.hir().node_to_string(item.hir_id)); + debug!("add_inferreds for item {}", self.tcx.hir().node_to_string(item.hir_id())); match item.kind { hir::ItemKind::Struct(ref struct_def, _) | hir::ItemKind::Union(ref struct_def, _) => { - self.add_inferreds_for_item(item.hir_id); + self.add_inferreds_for_item(item.hir_id()); if let hir::VariantData::Tuple(..) = *struct_def { self.add_inferreds_for_item(struct_def.ctor_hir_id().unwrap()); @@ -140,7 +140,7 @@ impl<'a, 'tcx, 'v> ItemLikeVisitor<'v> for TermsContext<'a, 'tcx> { } hir::ItemKind::Enum(ref enum_def, _) => { - self.add_inferreds_for_item(item.hir_id); + self.add_inferreds_for_item(item.hir_id()); for variant in enum_def.variants { if let hir::VariantData::Tuple(..) = variant.data { @@ -150,7 +150,7 @@ impl<'a, 'tcx, 'v> ItemLikeVisitor<'v> for TermsContext<'a, 'tcx> { } hir::ItemKind::Fn(..) => { - self.add_inferreds_for_item(item.hir_id); + self.add_inferreds_for_item(item.hir_id()); } _ => {} diff --git a/compiler/rustc_typeck/src/variance/test.rs b/compiler/rustc_typeck/src/variance/test.rs index d6e43b6d66950..2a0d950c87dab 100644 --- a/compiler/rustc_typeck/src/variance/test.rs +++ b/compiler/rustc_typeck/src/variance/test.rs @@ -14,12 +14,10 @@ struct VarianceTest<'tcx> { impl ItemLikeVisitor<'tcx> for VarianceTest<'tcx> { fn visit_item(&mut self, item: &'tcx hir::Item<'tcx>) { - let item_def_id = self.tcx.hir().local_def_id(item.hir_id); - // For unit testing: check for a special "rustc_variance" // attribute and report an error with various results if found. - if self.tcx.has_attr(item_def_id.to_def_id(), sym::rustc_variance) { - let variances_of = self.tcx.variances_of(item_def_id); + if self.tcx.has_attr(item.def_id.to_def_id(), sym::rustc_variance) { + let variances_of = self.tcx.variances_of(item.def_id); struct_span_err!(self.tcx.sess, item.span, E0208, "{:?}", variances_of).emit(); } } diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index e437362a4053e..411287de23f50 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -135,16 +135,15 @@ impl Clean for CrateNum { .filter_map(|&id| { let item = cx.tcx.hir().item(id); match item.kind { - hir::ItemKind::Mod(_) => as_primitive(Res::Def( - DefKind::Mod, - cx.tcx.hir().local_def_id(id.id).to_def_id(), - )), + hir::ItemKind::Mod(_) => { + as_primitive(Res::Def(DefKind::Mod, id.def_id.to_def_id())) + } hir::ItemKind::Use(ref path, hir::UseKind::Single) if item.vis.node.is_pub() => { as_primitive(path.res).map(|(_, prim)| { // Pretend the primitive is local. - (cx.tcx.hir().local_def_id(id.id).to_def_id(), prim) + (id.def_id.to_def_id(), prim) }) } _ => None, @@ -187,16 +186,13 @@ impl Clean for CrateNum { .filter_map(|&id| { let item = cx.tcx.hir().item(id); match item.kind { - hir::ItemKind::Mod(_) => as_keyword(Res::Def( - DefKind::Mod, - cx.tcx.hir().local_def_id(id.id).to_def_id(), - )), + hir::ItemKind::Mod(_) => { + as_keyword(Res::Def(DefKind::Mod, id.def_id.to_def_id())) + } hir::ItemKind::Use(ref path, hir::UseKind::Single) if item.vis.node.is_pub() => { - as_keyword(path.res).map(|(_, prim)| { - (cx.tcx.hir().local_def_id(id.id).to_def_id(), prim) - }) + as_keyword(path.res).map(|(_, prim)| (id.def_id.to_def_id(), prim)) } _ => None, } @@ -912,7 +908,7 @@ fn clean_fn_or_proc_macro( } None => { let mut func = (sig, generics, body_id).clean(cx); - let def_id = cx.tcx.hir().local_def_id(item.hir_id).to_def_id(); + let def_id = item.def_id.to_def_id(); func.header.constness = if is_const_fn(cx.tcx, def_id) && is_unstable_const_fn(cx.tcx, def_id).is_none() { hir::Constness::Const @@ -1950,8 +1946,8 @@ impl Clean> for (&hir::Item<'_>, Option) { use hir::ItemKind; let (item, renamed) = self; - let def_id = cx.tcx.hir().local_def_id(item.hir_id).to_def_id(); - let mut name = renamed.unwrap_or_else(|| cx.tcx.hir().name(item.hir_id)); + let def_id = item.def_id.to_def_id(); + let mut name = renamed.unwrap_or_else(|| cx.tcx.hir().name(item.hir_id())); cx.with_param_env(def_id, || { let kind = match item.kind { ItemKind::Static(ty, mutability, body_id) => { @@ -1999,7 +1995,7 @@ impl Clean> for (&hir::Item<'_>, Option) { fields: variant_data.fields().clean(cx), fields_stripped: false, }), - ItemKind::Impl(ref impl_) => return clean_impl(impl_, item.hir_id, cx), + ItemKind::Impl(ref impl_) => return clean_impl(impl_, item.hir_id(), cx), // proc macros can have a name set by attributes ItemKind::Fn(ref sig, ref generics, body_id) => { clean_fn_or_proc_macro(item, sig, generics, body_id, &mut name, cx) @@ -2107,8 +2103,7 @@ fn clean_extern_crate( cx: &DocContext<'_>, ) -> Vec { // this is the ID of the `extern crate` statement - let def_id = cx.tcx.hir().local_def_id(krate.hir_id); - let cnum = cx.tcx.extern_mod_stmt_cnum(def_id).unwrap_or(LOCAL_CRATE); + let cnum = cx.tcx.extern_mod_stmt_cnum(krate.def_id).unwrap_or(LOCAL_CRATE); // this is the ID of the crate itself let crate_def_id = DefId { krate: cnum, index: CRATE_DEF_INDEX }; let please_inline = krate.vis.node.is_pub() @@ -2127,7 +2122,7 @@ fn clean_extern_crate( if let Some(items) = inline::try_inline( cx, - cx.tcx.parent_module(krate.hir_id).to_def_id(), + cx.tcx.parent_module(krate.hir_id()).to_def_id(), res, name, Some(krate.attrs), @@ -2196,7 +2191,6 @@ fn clean_use_statement( // Also check whether imports were asked to be inlined, in case we're trying to re-export a // crate in Rust 2018+ - let def_id = cx.tcx.hir().local_def_id(import.hir_id).to_def_id(); let path = path.clean(cx); let inner = if kind == hir::UseKind::Glob { if !denied { @@ -2221,14 +2215,14 @@ fn clean_use_statement( if let Some(mut items) = inline::try_inline( cx, - cx.tcx.parent_module(import.hir_id).to_def_id(), + cx.tcx.parent_module(import.hir_id()).to_def_id(), path.res, name, Some(import.attrs), &mut visited, ) { items.push(Item::from_def_id_and_parts( - def_id, + import.def_id.to_def_id(), None, ImportItem(Import::new_simple(name, resolve_use_source(cx, path), false)), cx, @@ -2239,7 +2233,7 @@ fn clean_use_statement( Import::new_simple(name, resolve_use_source(cx, path), true) }; - vec![Item::from_def_id_and_parts(def_id, None, ImportItem(inner), cx)] + vec![Item::from_def_id_and_parts(import.def_id.to_def_id(), None, ImportItem(inner), cx)] } impl Clean for (&hir::ForeignItem<'_>, Option) { diff --git a/src/librustdoc/doctest.rs b/src/librustdoc/doctest.rs index fb4774ae19246..10015afb166fd 100644 --- a/src/librustdoc/doctest.rs +++ b/src/librustdoc/doctest.rs @@ -1050,7 +1050,7 @@ impl<'a, 'hir, 'tcx> intravisit::Visitor<'hir> for HirCollector<'a, 'hir, 'tcx> item.ident.to_string() }; - self.visit_testable(name, &item.attrs, item.hir_id, item.span, |this| { + self.visit_testable(name, &item.attrs, item.hir_id(), item.span, |this| { intravisit::walk_item(this, item); }); } diff --git a/src/librustdoc/visit_ast.rs b/src/librustdoc/visit_ast.rs index 013e27c122940..73d096749f470 100644 --- a/src/librustdoc/visit_ast.rs +++ b/src/librustdoc/visit_ast.rs @@ -270,8 +270,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> { let name = renamed.unwrap_or(item.ident.name); if item.vis.node.is_pub() { - let def_id = self.cx.tcx.hir().local_def_id(item.hir_id); - self.store_path(def_id.to_def_id()); + self.store_path(item.def_id.to_def_id()); } match item.kind { @@ -305,7 +304,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> { }); let ident = if is_glob { None } else { Some(name) }; if self.maybe_inline_local( - item.hir_id, + item.hir_id(), path.res, ident, is_glob, @@ -322,7 +321,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> { om.mods.push(self.visit_mod_contents( item.span, &item.vis, - item.hir_id, + item.hir_id(), m, Some(name), )); diff --git a/src/tools/clippy/clippy_lints/src/copy_iterator.rs b/src/tools/clippy/clippy_lints/src/copy_iterator.rs index 48899b3389937..004bce5f62a8f 100644 --- a/src/tools/clippy/clippy_lints/src/copy_iterator.rs +++ b/src/tools/clippy/clippy_lints/src/copy_iterator.rs @@ -38,7 +38,7 @@ impl<'tcx> LateLintPass<'tcx> for CopyIterator { .. }) = item.kind { - let ty = cx.tcx.type_of(cx.tcx.hir().local_def_id(item.hir_id)); + let ty = cx.tcx.type_of(item.def_id); if is_copy(cx, ty) && match_path(&trait_ref.path, &paths::ITERATOR) { span_lint_and_note( diff --git a/src/tools/clippy/clippy_lints/src/derive.rs b/src/tools/clippy/clippy_lints/src/derive.rs index b1e363663bb27..e8510bde9adcd 100644 --- a/src/tools/clippy/clippy_lints/src/derive.rs +++ b/src/tools/clippy/clippy_lints/src/derive.rs @@ -169,7 +169,7 @@ impl<'tcx> LateLintPass<'tcx> for Derive { .. }) = item.kind { - let ty = cx.tcx.type_of(cx.tcx.hir().local_def_id(item.hir_id)); + let ty = cx.tcx.type_of(item.def_id); let is_automatically_derived = is_automatically_derived(&*item.attrs); check_hash_peq(cx, item.span, trait_ref, ty, is_automatically_derived); diff --git a/src/tools/clippy/clippy_lints/src/doc.rs b/src/tools/clippy/clippy_lints/src/doc.rs index 75e71eb1e4ce2..c12448588891a 100644 --- a/src/tools/clippy/clippy_lints/src/doc.rs +++ b/src/tools/clippy/clippy_lints/src/doc.rs @@ -216,18 +216,17 @@ impl<'tcx> LateLintPass<'tcx> for DocMarkdown { let headers = check_attrs(cx, &self.valid_idents, &item.attrs); match item.kind { hir::ItemKind::Fn(ref sig, _, body_id) => { - if !(is_entrypoint_fn(cx, cx.tcx.hir().local_def_id(item.hir_id).to_def_id()) + if !(is_entrypoint_fn(cx, item.def_id.to_def_id()) || in_external_macro(cx.tcx.sess, item.span)) { let body = cx.tcx.hir().body(body_id); - let impl_item_def_id = cx.tcx.hir().local_def_id(item.hir_id); let mut fpu = FindPanicUnwrap { cx, - typeck_results: cx.tcx.typeck(impl_item_def_id), + typeck_results: cx.tcx.typeck(item.def_id), panic_span: None, }; fpu.visit_expr(&body.value); - lint_for_missing_headers(cx, item.hir_id, item.span, sig, headers, Some(body_id), fpu.panic_span); + lint_for_missing_headers(cx, item.hir_id(), item.span, sig, headers, Some(body_id), fpu.panic_span); } }, hir::ItemKind::Impl(ref impl_) => { diff --git a/src/tools/clippy/clippy_lints/src/empty_enum.rs b/src/tools/clippy/clippy_lints/src/empty_enum.rs index 853b3afdc3ae2..077c3b75fb8c8 100644 --- a/src/tools/clippy/clippy_lints/src/empty_enum.rs +++ b/src/tools/clippy/clippy_lints/src/empty_enum.rs @@ -49,9 +49,8 @@ impl<'tcx> LateLintPass<'tcx> for EmptyEnum { return; } - let did = cx.tcx.hir().local_def_id(item.hir_id); if let ItemKind::Enum(..) = item.kind { - let ty = cx.tcx.type_of(did); + let ty = cx.tcx.type_of(item.def_id); let adt = ty.ty_adt_def().expect("already checked whether this is an enum"); if adt.variants.is_empty() { span_lint_and_help( diff --git a/src/tools/clippy/clippy_lints/src/exhaustive_items.rs b/src/tools/clippy/clippy_lints/src/exhaustive_items.rs index e3988d0038c23..ab9be3398bfa6 100644 --- a/src/tools/clippy/clippy_lints/src/exhaustive_items.rs +++ b/src/tools/clippy/clippy_lints/src/exhaustive_items.rs @@ -72,7 +72,7 @@ impl LateLintPass<'_> for ExhaustiveItems { fn check_item(&mut self, cx: &LateContext<'_>, item: &Item<'_>) { if_chain! { if let ItemKind::Enum(..) | ItemKind::Struct(..) = item.kind; - if cx.access_levels.is_exported(item.hir_id); + if cx.access_levels.is_exported(item.hir_id()); if !item.attrs.iter().any(|a| a.has_name(sym::non_exhaustive)); then { let (lint, msg) = if let ItemKind::Struct(ref v, ..) = item.kind { diff --git a/src/tools/clippy/clippy_lints/src/fallible_impl_from.rs b/src/tools/clippy/clippy_lints/src/fallible_impl_from.rs index 527905e375d28..79828efc206d6 100644 --- a/src/tools/clippy/clippy_lints/src/fallible_impl_from.rs +++ b/src/tools/clippy/clippy_lints/src/fallible_impl_from.rs @@ -52,10 +52,9 @@ declare_lint_pass!(FallibleImplFrom => [FALLIBLE_IMPL_FROM]); impl<'tcx> LateLintPass<'tcx> for FallibleImplFrom { fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) { // check for `impl From for ..` - let impl_def_id = cx.tcx.hir().local_def_id(item.hir_id); if_chain! { if let hir::ItemKind::Impl(impl_) = &item.kind; - if let Some(impl_trait_ref) = cx.tcx.impl_trait_ref(impl_def_id); + if let Some(impl_trait_ref) = cx.tcx.impl_trait_ref(item.def_id); if cx.tcx.is_diagnostic_item(sym::from_trait, impl_trait_ref.def_id); then { lint_impl_body(cx, item.span, impl_.items); diff --git a/src/tools/clippy/clippy_lints/src/from_over_into.rs b/src/tools/clippy/clippy_lints/src/from_over_into.rs index b010abda24d10..b644bb079908f 100644 --- a/src/tools/clippy/clippy_lints/src/from_over_into.rs +++ b/src/tools/clippy/clippy_lints/src/from_over_into.rs @@ -60,10 +60,9 @@ impl LateLintPass<'_> for FromOverInto { return; } - let impl_def_id = cx.tcx.hir().local_def_id(item.hir_id); if_chain! { if let hir::ItemKind::Impl{ .. } = &item.kind; - if let Some(impl_trait_ref) = cx.tcx.impl_trait_ref(impl_def_id); + if let Some(impl_trait_ref) = cx.tcx.impl_trait_ref(item.def_id); if match_def_path(cx, impl_trait_ref.def_id, &INTO); then { diff --git a/src/tools/clippy/clippy_lints/src/functions.rs b/src/tools/clippy/clippy_lints/src/functions.rs index 71a146cc29805..28d025315cfeb 100644 --- a/src/tools/clippy/clippy_lints/src/functions.rs +++ b/src/tools/clippy/clippy_lints/src/functions.rs @@ -283,13 +283,13 @@ impl<'tcx> LateLintPass<'tcx> for Functions { fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) { let attr = must_use_attr(&item.attrs); if let hir::ItemKind::Fn(ref sig, ref _generics, ref body_id) = item.kind { - let is_public = cx.access_levels.is_exported(item.hir_id); + let is_public = cx.access_levels.is_exported(item.hir_id()); let fn_header_span = item.span.with_hi(sig.decl.output.span().hi()); if is_public { check_result_unit_err(cx, &sig.decl, item.span, fn_header_span); } if let Some(attr) = attr { - check_needless_must_use(cx, &sig.decl, item.hir_id, item.span, fn_header_span, attr); + check_needless_must_use(cx, &sig.decl, item.hir_id(), item.span, fn_header_span, attr); return; } if is_public && !is_proc_macro(cx.sess(), &item.attrs) && attr_by_name(&item.attrs, "no_mangle").is_none() { @@ -298,7 +298,7 @@ impl<'tcx> LateLintPass<'tcx> for Functions { &sig.decl, cx.tcx.hir().body(*body_id), item.span, - item.hir_id, + item.hir_id(), item.span.with_hi(sig.decl.output.span().hi()), "this function could have a `#[must_use]` attribute", ); diff --git a/src/tools/clippy/clippy_lints/src/inherent_impl.rs b/src/tools/clippy/clippy_lints/src/inherent_impl.rs index ea26c84cde16a..005c461f105e6 100644 --- a/src/tools/clippy/clippy_lints/src/inherent_impl.rs +++ b/src/tools/clippy/clippy_lints/src/inherent_impl.rs @@ -59,20 +59,15 @@ impl<'tcx> LateLintPass<'tcx> for MultipleInherentImpl { // but filter out implementations that have generic params (type or lifetime) // or are derived from a macro if !in_macro(item.span) && generics.params.is_empty() { - self.impls.insert(item.hir_id.owner.to_def_id(), item.span); + self.impls.insert(item.def_id.to_def_id(), item.span); } } } fn check_crate_post(&mut self, cx: &LateContext<'tcx>, krate: &'tcx Crate<'_>) { - if let Some(item) = krate.items.values().next() { + if !krate.items.is_empty() { // Retrieve all inherent implementations from the crate, grouped by type - for impls in cx - .tcx - .crate_inherent_impls(item.hir_id.owner.to_def_id().krate) - .inherent_impls - .values() - { + for impls in cx.tcx.crate_inherent_impls(def_id::LOCAL_CRATE).inherent_impls.values() { // Filter out implementations that have generic params (type or lifetime) let mut impl_spans = impls.iter().filter_map(|impl_def| self.impls.get(impl_def)); if let Some(initial_span) = impl_spans.next() { diff --git a/src/tools/clippy/clippy_lints/src/large_enum_variant.rs b/src/tools/clippy/clippy_lints/src/large_enum_variant.rs index ad9b4f357a74d..ab4cb33612d38 100644 --- a/src/tools/clippy/clippy_lints/src/large_enum_variant.rs +++ b/src/tools/clippy/clippy_lints/src/large_enum_variant.rs @@ -62,9 +62,8 @@ impl<'tcx> LateLintPass<'tcx> for LargeEnumVariant { if in_external_macro(cx.tcx.sess, item.span) { return; } - let did = cx.tcx.hir().local_def_id(item.hir_id); if let ItemKind::Enum(ref def, _) = item.kind { - let ty = cx.tcx.type_of(did); + let ty = cx.tcx.type_of(item.def_id); let adt = ty.ty_adt_def().expect("already checked whether this is an enum"); let mut largest_variant: Option<(_, _)> = None; diff --git a/src/tools/clippy/clippy_lints/src/len_zero.rs b/src/tools/clippy/clippy_lints/src/len_zero.rs index e95caf6a35f90..8706cf7f02b92 100644 --- a/src/tools/clippy/clippy_lints/src/len_zero.rs +++ b/src/tools/clippy/clippy_lints/src/len_zero.rs @@ -177,10 +177,9 @@ fn check_trait_items(cx: &LateContext<'_>, visited_trait: &Item<'_>, trait_items } } - if cx.access_levels.is_exported(visited_trait.hir_id) && trait_items.iter().any(|i| is_named_self(cx, i, "len")) { + if cx.access_levels.is_exported(visited_trait.hir_id()) && trait_items.iter().any(|i| is_named_self(cx, i, "len")) { let mut current_and_super_traits = FxHashSet::default(); - let visited_trait_def_id = cx.tcx.hir().local_def_id(visited_trait.hir_id); - fill_trait_set(visited_trait_def_id.to_def_id(), &mut current_and_super_traits, cx); + fill_trait_set(visited_trait.def_id.to_def_id(), &mut current_and_super_traits, cx); let is_empty_method_found = current_and_super_traits .iter() @@ -230,8 +229,7 @@ fn check_impl_items(cx: &LateContext<'_>, item: &Item<'_>, impl_items: &[ImplIte if let Some(i) = impl_items.iter().find(|i| is_named_self(cx, i, "len")) { if cx.access_levels.is_exported(i.id.hir_id) { - let def_id = cx.tcx.hir().local_def_id(item.hir_id); - let ty = cx.tcx.type_of(def_id); + let ty = cx.tcx.type_of(item.def_id); span_lint( cx, diff --git a/src/tools/clippy/clippy_lints/src/methods/mod.rs b/src/tools/clippy/clippy_lints/src/methods/mod.rs index 0918843294d47..a2104b48b4ffd 100644 --- a/src/tools/clippy/clippy_lints/src/methods/mod.rs +++ b/src/tools/clippy/clippy_lints/src/methods/mod.rs @@ -1687,8 +1687,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods { let name = impl_item.ident.name.as_str(); let parent = cx.tcx.hir().get_parent_item(impl_item.hir_id); let item = cx.tcx.hir().expect_item(parent); - let def_id = cx.tcx.hir().local_def_id(item.hir_id); - let self_ty = cx.tcx.type_of(def_id); + let self_ty = cx.tcx.type_of(item.def_id); // if this impl block implements a trait, lint in trait definition instead if let hir::ItemKind::Impl(hir::Impl { of_trait: Some(_), .. }) = item.kind { diff --git a/src/tools/clippy/clippy_lints/src/missing_doc.rs b/src/tools/clippy/clippy_lints/src/missing_doc.rs index 0e49eaab43685..21b59fba995fc 100644 --- a/src/tools/clippy/clippy_lints/src/missing_doc.rs +++ b/src/tools/clippy/clippy_lints/src/missing_doc.rs @@ -135,8 +135,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc { hir::ItemKind::Fn(..) => { // ignore main() if it.ident.name == sym::main { - let def_id = it.hir_id.owner; - let def_key = cx.tcx.hir().def_key(def_id); + let def_key = cx.tcx.hir().def_key(it.def_id); if def_key.parent == Some(hir::def_id::CRATE_DEF_INDEX) { return; } @@ -159,8 +158,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc { | hir::ItemKind::Use(..) => return, }; - let def_id = cx.tcx.hir().local_def_id(it.hir_id); - let (article, desc) = cx.tcx.article_and_description(def_id.to_def_id()); + let (article, desc) = cx.tcx.article_and_description(it.def_id.to_def_id()); self.check_missing_docs_attrs(cx, &it.attrs, it.span, article, desc); } diff --git a/src/tools/clippy/clippy_lints/src/missing_inline.rs b/src/tools/clippy/clippy_lints/src/missing_inline.rs index 1264813d378a3..5132bed590a0c 100644 --- a/src/tools/clippy/clippy_lints/src/missing_inline.rs +++ b/src/tools/clippy/clippy_lints/src/missing_inline.rs @@ -87,7 +87,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingInline { return; } - if !cx.access_levels.is_exported(it.hir_id) { + if !cx.access_levels.is_exported(it.hir_id()) { return; } match it.kind { diff --git a/src/tools/clippy/clippy_lints/src/mut_key.rs b/src/tools/clippy/clippy_lints/src/mut_key.rs index 11044e0c2fb48..7b9205a99de1b 100644 --- a/src/tools/clippy/clippy_lints/src/mut_key.rs +++ b/src/tools/clippy/clippy_lints/src/mut_key.rs @@ -57,7 +57,7 @@ declare_lint_pass!(MutableKeyType => [ MUTABLE_KEY_TYPE ]); impl<'tcx> LateLintPass<'tcx> for MutableKeyType { fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'tcx>) { if let hir::ItemKind::Fn(ref sig, ..) = item.kind { - check_sig(cx, item.hir_id, &sig.decl); + check_sig(cx, item.hir_id(), &sig.decl); } } diff --git a/src/tools/clippy/clippy_lints/src/needless_borrow.rs b/src/tools/clippy/clippy_lints/src/needless_borrow.rs index f1c06692e30d9..1453ea6e8975d 100644 --- a/src/tools/clippy/clippy_lints/src/needless_borrow.rs +++ b/src/tools/clippy/clippy_lints/src/needless_borrow.rs @@ -5,11 +5,12 @@ use crate::utils::{is_automatically_derived, snippet_opt, span_lint_and_then}; use if_chain::if_chain; use rustc_errors::Applicability; -use rustc_hir::{BindingAnnotation, BorrowKind, Expr, ExprKind, HirId, Item, Mutability, Pat, PatKind}; +use rustc_hir::{BindingAnnotation, BorrowKind, Expr, ExprKind, Item, Mutability, Pat, PatKind}; use rustc_lint::{LateContext, LateLintPass}; use rustc_middle::ty; use rustc_middle::ty::adjustment::{Adjust, Adjustment}; use rustc_session::{declare_tool_lint, impl_lint_pass}; +use rustc_span::def_id::LocalDefId; declare_clippy_lint! { /// **What it does:** Checks for address of operations (`&`) that are going to @@ -35,7 +36,7 @@ declare_clippy_lint! { #[derive(Default)] pub struct NeedlessBorrow { - derived_item: Option, + derived_item: Option, } impl_lint_pass!(NeedlessBorrow => [NEEDLESS_BORROW]); @@ -117,13 +118,13 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBorrow { fn check_item(&mut self, _: &LateContext<'tcx>, item: &'tcx Item<'_>) { if is_automatically_derived(item.attrs) { debug_assert!(self.derived_item.is_none()); - self.derived_item = Some(item.hir_id); + self.derived_item = Some(item.def_id); } } fn check_item_post(&mut self, _: &LateContext<'tcx>, item: &'tcx Item<'_>) { if let Some(id) = self.derived_item { - if item.hir_id == id { + if item.def_id == id { self.derived_item = None; } } diff --git a/src/tools/clippy/clippy_lints/src/ptr.rs b/src/tools/clippy/clippy_lints/src/ptr.rs index b5aa34111402c..9efeac3d82383 100644 --- a/src/tools/clippy/clippy_lints/src/ptr.rs +++ b/src/tools/clippy/clippy_lints/src/ptr.rs @@ -124,7 +124,7 @@ declare_lint_pass!(Ptr => [PTR_ARG, CMP_NULL, MUT_FROM_REF]); impl<'tcx> LateLintPass<'tcx> for Ptr { fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'_>) { if let ItemKind::Fn(ref sig, _, body_id) = item.kind { - check_fn(cx, &sig.decl, item.hir_id, Some(body_id)); + check_fn(cx, &sig.decl, item.hir_id(), Some(body_id)); } } diff --git a/src/tools/clippy/clippy_lints/src/redundant_pub_crate.rs b/src/tools/clippy/clippy_lints/src/redundant_pub_crate.rs index acd9047ace617..c876bae2303ad 100644 --- a/src/tools/clippy/clippy_lints/src/redundant_pub_crate.rs +++ b/src/tools/clippy/clippy_lints/src/redundant_pub_crate.rs @@ -42,11 +42,10 @@ impl_lint_pass!(RedundantPubCrate => [REDUNDANT_PUB_CRATE]); impl<'tcx> LateLintPass<'tcx> for RedundantPubCrate { fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) { if let VisibilityKind::Crate { .. } = item.vis.node { - if !cx.access_levels.is_exported(item.hir_id) { + if !cx.access_levels.is_exported(item.hir_id()) { if let Some(false) = self.is_exported.last() { let span = item.span.with_hi(item.ident.span.hi()); - let def_id = cx.tcx.hir().local_def_id(item.hir_id); - let descr = cx.tcx.def_kind(def_id).descr(def_id.to_def_id()); + let descr = cx.tcx.def_kind(item.def_id).descr(item.def_id.to_def_id()); span_lint_and_then( cx, REDUNDANT_PUB_CRATE, @@ -66,7 +65,7 @@ impl<'tcx> LateLintPass<'tcx> for RedundantPubCrate { } if let ItemKind::Mod { .. } = item.kind { - self.is_exported.push(cx.access_levels.is_exported(item.hir_id)); + self.is_exported.push(cx.access_levels.is_exported(item.hir_id())); } } diff --git a/src/tools/clippy/clippy_lints/src/types.rs b/src/tools/clippy/clippy_lints/src/types.rs index 58af5b12c3735..05754503163bd 100644 --- a/src/tools/clippy/clippy_lints/src/types.rs +++ b/src/tools/clippy/clippy_lints/src/types.rs @@ -1106,7 +1106,9 @@ fn is_empty_block(expr: &Expr<'_>) -> bool { expr.kind, ExprKind::Block( Block { - stmts: &[], expr: None, .. + stmts: &[], + expr: None, + .. }, _, ) @@ -2565,7 +2567,7 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitHasher { } } - if !cx.access_levels.is_exported(item.hir_id) { + if !cx.access_levels.is_exported(item.hir_id()) { return; } diff --git a/src/tools/clippy/clippy_lints/src/use_self.rs b/src/tools/clippy/clippy_lints/src/use_self.rs index 72d1ca7392913..f2ff8c959c2e6 100644 --- a/src/tools/clippy/clippy_lints/src/use_self.rs +++ b/src/tools/clippy/clippy_lints/src/use_self.rs @@ -196,8 +196,7 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf { item_path, cx, }; - let impl_def_id = cx.tcx.hir().local_def_id(item.hir_id); - let impl_trait_ref = cx.tcx.impl_trait_ref(impl_def_id); + let impl_trait_ref = cx.tcx.impl_trait_ref(item.def_id); if let Some(impl_trait_ref) = impl_trait_ref { for impl_item_ref in impl_.items { diff --git a/src/tools/clippy/clippy_lints/src/utils/inspector.rs b/src/tools/clippy/clippy_lints/src/utils/inspector.rs index b52083af6fd34..9c1d98cd70745 100644 --- a/src/tools/clippy/clippy_lints/src/utils/inspector.rs +++ b/src/tools/clippy/clippy_lints/src/utils/inspector.rs @@ -370,7 +370,7 @@ fn print_expr(cx: &LateContext<'_>, expr: &hir::Expr<'_>, indent: usize) { } fn print_item(cx: &LateContext<'_>, item: &hir::Item<'_>) { - let did = cx.tcx.hir().local_def_id(item.hir_id); + let did = item.def_id; println!("item `{}`", item.ident.name); match item.vis.node { hir::VisibilityKind::Public => println!("public"), @@ -383,8 +383,7 @@ fn print_item(cx: &LateContext<'_>, item: &hir::Item<'_>) { } match item.kind { hir::ItemKind::ExternCrate(ref _renamed_from) => { - let def_id = cx.tcx.hir().local_def_id(item.hir_id); - if let Some(crate_id) = cx.tcx.extern_mod_stmt_cnum(def_id) { + if let Some(crate_id) = cx.tcx.extern_mod_stmt_cnum(did) { let source = cx.tcx.used_crate_source(crate_id); if let Some(ref src) = source.dylib { println!("extern crate dylib source: {:?}", src.0); diff --git a/src/tools/clippy/clippy_lints/src/wildcard_imports.rs b/src/tools/clippy/clippy_lints/src/wildcard_imports.rs index 10005a7fc81ed..094b1a42346c2 100644 --- a/src/tools/clippy/clippy_lints/src/wildcard_imports.rs +++ b/src/tools/clippy/clippy_lints/src/wildcard_imports.rs @@ -113,7 +113,7 @@ impl LateLintPass<'_> for WildcardImports { if_chain! { if let ItemKind::Use(use_path, UseKind::Glob) = &item.kind; if self.warn_on_all || !self.check_exceptions(item, use_path.segments); - let used_imports = cx.tcx.names_imported_by_glob_use(item.hir_id.owner); + let used_imports = cx.tcx.names_imported_by_glob_use(item.def_id); if !used_imports.is_empty(); // Already handled by `unused_imports` then { let mut applicability = Applicability::MachineApplicable; From a871a0f11196ed028edeedc4843338f702880672 Mon Sep 17 00:00:00 2001 From: Camille GILLOT Date: Sat, 30 Jan 2021 20:46:50 +0100 Subject: [PATCH 06/14] Only store a LocalDefId in hir::TraitItem. --- compiler/rustc_ast_lowering/src/item.rs | 6 ++-- compiler/rustc_hir/src/hir.rs | 29 +++++++++++++++---- compiler/rustc_hir/src/intravisit.rs | 8 ++--- compiler/rustc_hir/src/stable_hash_impls.rs | 10 +++---- compiler/rustc_hir_pretty/src/lib.rs | 4 +-- .../rustc_incremental/src/assert_dep_graph.rs | 2 +- .../src/persist/dirty_clean.rs | 2 +- .../nice_region_error/static_impl_trait.rs | 9 +++--- compiler/rustc_lint/src/builtin.rs | 9 +++--- compiler/rustc_lint/src/late.rs | 4 +-- compiler/rustc_lint/src/levels.rs | 2 +- compiler/rustc_middle/src/hir/map/blocks.rs | 2 +- .../rustc_middle/src/hir/map/collector.rs | 10 ++----- compiler/rustc_middle/src/hir/map/mod.rs | 2 +- compiler/rustc_middle/src/ty/error.rs | 2 +- compiler/rustc_passes/src/check_attr.rs | 8 ++++- compiler/rustc_passes/src/dead.rs | 4 +-- compiler/rustc_passes/src/diagnostic_items.rs | 2 +- compiler/rustc_passes/src/hir_id_validator.rs | 2 +- compiler/rustc_passes/src/hir_stats.rs | 2 +- compiler/rustc_passes/src/lang_items.rs | 2 +- compiler/rustc_passes/src/stability.rs | 4 +-- compiler/rustc_privacy/src/lib.rs | 8 ++--- compiler/rustc_resolve/src/late/lifetimes.rs | 7 +++-- .../rustc_save_analysis/src/dump_visitor.rs | 17 +++++------ compiler/rustc_symbol_mangling/src/test.rs | 2 +- compiler/rustc_ty_utils/src/ty.rs | 11 ++++--- compiler/rustc_typeck/src/check/check.rs | 3 +- .../rustc_typeck/src/check/compare_method.rs | 4 +-- compiler/rustc_typeck/src/check/wfcheck.rs | 7 ++--- compiler/rustc_typeck/src/collect.rs | 25 ++++++++-------- compiler/rustc_typeck/src/collect/type_of.rs | 3 +- .../rustc_typeck/src/variance/constraints.rs | 2 +- compiler/rustc_typeck/src/variance/terms.rs | 2 +- src/librustdoc/clean/mod.rs | 2 +- src/librustdoc/doctest.rs | 12 ++++++-- src/tools/clippy/clippy_lints/src/doc.rs | 2 +- src/tools/clippy/clippy_lints/src/escape.rs | 4 +-- .../clippy/clippy_lints/src/functions.rs | 8 ++--- src/tools/clippy/clippy_lints/src/len_zero.rs | 5 +--- .../clippy/clippy_lints/src/methods/mod.rs | 6 ++-- .../clippy/clippy_lints/src/missing_doc.rs | 3 +- src/tools/clippy/clippy_lints/src/mut_key.rs | 2 +- .../clippy_lints/src/pass_by_ref_or_value.rs | 2 +- src/tools/clippy/clippy_lints/src/ptr.rs | 2 +- 45 files changed, 139 insertions(+), 125 deletions(-) diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs index 8750c2654c5f5..192ca79e78006 100644 --- a/compiler/rustc_ast_lowering/src/item.rs +++ b/compiler/rustc_ast_lowering/src/item.rs @@ -92,7 +92,7 @@ impl<'a> Visitor<'a> for ItemLowerer<'a, '_, '_> { self.lctx.with_hir_id_owner(item.id, |lctx| match ctxt { AssocCtxt::Trait => { let hir_item = lctx.lower_trait_item(item); - let id = hir::TraitItemId { hir_id: hir_item.hir_id }; + let id = hir_item.trait_item_id(); lctx.trait_items.insert(id, hir_item); lctx.modules.get_mut(&lctx.current_module).unwrap().trait_items.insert(id); } @@ -846,7 +846,7 @@ impl<'hir> LoweringContext<'_, 'hir> { }; hir::TraitItem { - hir_id: self.lower_node_id(i.id), + def_id: trait_item_def_id, ident: i.ident, attrs: self.lower_attrs(&i.attrs), generics, @@ -866,7 +866,7 @@ impl<'hir> LoweringContext<'_, 'hir> { } AssocItemKind::MacCall(..) => unimplemented!(), }; - let id = hir::TraitItemId { hir_id: self.lower_node_id(i.id) }; + let id = hir::TraitItemId { def_id: self.lower_node_id(i.id).expect_owner() }; let defaultness = hir::Defaultness::Default { has_value: has_default }; hir::TraitItemRef { id, ident: i.ident, span: i.span, defaultness, kind } } diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs index 2abb8fb273125..d47e0a4629ab1 100644 --- a/compiler/rustc_hir/src/hir.rs +++ b/compiler/rustc_hir/src/hir.rs @@ -1907,7 +1907,14 @@ pub struct FnSig<'hir> { // so it can fetched later. #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Encodable, Debug)] pub struct TraitItemId { - pub hir_id: HirId, + pub def_id: LocalDefId, +} + +impl TraitItemId { + pub fn hir_id(&self) -> HirId { + // Items are always HIR owners. + HirId::make_owner(self.def_id) + } } /// Represents an item declaration within a trait declaration, @@ -1917,13 +1924,24 @@ pub struct TraitItemId { #[derive(Debug)] pub struct TraitItem<'hir> { pub ident: Ident, - pub hir_id: HirId, + pub def_id: LocalDefId, pub attrs: &'hir [Attribute], pub generics: Generics<'hir>, pub kind: TraitItemKind<'hir>, pub span: Span, } +impl TraitItem<'_> { + pub fn hir_id(&self) -> HirId { + // Items are always HIR owners. + HirId::make_owner(self.def_id) + } + + pub fn trait_item_id(&self) -> TraitItemId { + TraitItemId { def_id: self.def_id } + } +} + /// Represents a trait method's body (or just argument names). #[derive(Encodable, Debug, HashStable_Generic)] pub enum TraitFn<'hir> { @@ -2885,9 +2903,10 @@ impl<'hir> Node<'hir> { pub fn hir_id(&self) -> Option { match self { - Node::Item(Item { def_id, .. }) => Some(HirId::make_owner(*def_id)), + Node::Item(Item { def_id, .. }) | Node::TraitItem(TraitItem { def_id, .. }) => { + Some(HirId::make_owner(*def_id)) + } Node::ForeignItem(ForeignItem { hir_id, .. }) - | Node::TraitItem(TraitItem { hir_id, .. }) | Node::ImplItem(ImplItem { hir_id, .. }) | Node::Field(StructField { hir_id, .. }) | Node::AnonConst(AnonConst { hir_id, .. }) @@ -2922,7 +2941,7 @@ mod size_asserts { rustc_data_structures::static_assert_size!(super::Ty<'static>, 72); rustc_data_structures::static_assert_size!(super::Item<'static>, 200); - rustc_data_structures::static_assert_size!(super::TraitItem<'static>, 152); + rustc_data_structures::static_assert_size!(super::TraitItem<'static>, 144); rustc_data_structures::static_assert_size!(super::ImplItem<'static>, 168); rustc_data_structures::static_assert_size!(super::ForeignItem<'static>, 160); } diff --git a/compiler/rustc_hir/src/intravisit.rs b/compiler/rustc_hir/src/intravisit.rs index e492cef7733ae..a145d4dc47688 100644 --- a/compiler/rustc_hir/src/intravisit.rs +++ b/compiler/rustc_hir/src/intravisit.rs @@ -964,12 +964,12 @@ pub fn walk_trait_item<'v, V: Visitor<'v>>(visitor: &mut V, trait_item: &'v Trai visitor.visit_generics(&trait_item.generics); match trait_item.kind { TraitItemKind::Const(ref ty, default) => { - visitor.visit_id(trait_item.hir_id); + visitor.visit_id(trait_item.hir_id()); visitor.visit_ty(ty); walk_list!(visitor, visit_nested_body, default); } TraitItemKind::Fn(ref sig, TraitFn::Required(param_names)) => { - visitor.visit_id(trait_item.hir_id); + visitor.visit_id(trait_item.hir_id()); visitor.visit_fn_decl(&sig.decl); for ¶m_name in param_names { visitor.visit_ident(param_name); @@ -981,11 +981,11 @@ pub fn walk_trait_item<'v, V: Visitor<'v>>(visitor: &mut V, trait_item: &'v Trai &sig.decl, body_id, trait_item.span, - trait_item.hir_id, + trait_item.hir_id(), ); } TraitItemKind::Type(bounds, ref default) => { - visitor.visit_id(trait_item.hir_id); + visitor.visit_id(trait_item.hir_id()); walk_list!(visitor, visit_param_bound, bounds); walk_list!(visitor, visit_ty, default); } diff --git a/compiler/rustc_hir/src/stable_hash_impls.rs b/compiler/rustc_hir/src/stable_hash_impls.rs index b0d332e0028f0..e7e676fe147b9 100644 --- a/compiler/rustc_hir/src/stable_hash_impls.rs +++ b/compiler/rustc_hir/src/stable_hash_impls.rs @@ -44,11 +44,11 @@ impl ToStableHashKey for ItemId { } impl ToStableHashKey for TraitItemId { - type KeyType = (DefPathHash, ItemLocalId); + type KeyType = DefPathHash; #[inline] - fn to_stable_hash_key(&self, hcx: &HirCtx) -> (DefPathHash, ItemLocalId) { - self.hir_id.to_stable_hash_key(hcx) + fn to_stable_hash_key(&self, hcx: &HirCtx) -> DefPathHash { + hcx.local_def_path_hash(self.def_id) } } @@ -109,7 +109,7 @@ impl HashStable for ImplItemId { impl HashStable for TraitItemId { fn hash_stable(&self, hcx: &mut HirCtx, hasher: &mut StableHasher) { - hcx.hash_reference_to_item(self.hir_id, hasher) + hcx.hash_reference_to_item(self.hir_id(), hasher) } } @@ -139,7 +139,7 @@ impl HashStable for VisibilityKind<'_> impl HashStable for TraitItem<'_> { fn hash_stable(&self, hcx: &mut HirCtx, hasher: &mut StableHasher) { - let TraitItem { hir_id: _, ident, ref attrs, ref generics, ref kind, span } = *self; + let TraitItem { def_id: _, ident, ref attrs, ref generics, ref kind, span } = *self; hcx.hash_hir_item_like(|hcx| { ident.name.hash_stable(hcx, hasher); diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs index e6805b171c579..72a5804f50f7f 100644 --- a/compiler/rustc_hir_pretty/src/lib.rs +++ b/compiler/rustc_hir_pretty/src/lib.rs @@ -934,7 +934,7 @@ impl<'a> State<'a> { } pub fn print_trait_item(&mut self, ti: &hir::TraitItem<'_>) { - self.ann.pre(self, AnnNode::SubItem(ti.hir_id)); + self.ann.pre(self, AnnNode::SubItem(ti.hir_id())); self.hardbreak_if_not_bol(); self.maybe_print_comment(ti.span.lo()); self.print_outer_attributes(&ti.attrs); @@ -969,7 +969,7 @@ impl<'a> State<'a> { ); } } - self.ann.post(self, AnnNode::SubItem(ti.hir_id)) + self.ann.post(self, AnnNode::SubItem(ti.hir_id())) } pub fn print_impl_item(&mut self, ii: &hir::ImplItem<'_>) { diff --git a/compiler/rustc_incremental/src/assert_dep_graph.rs b/compiler/rustc_incremental/src/assert_dep_graph.rs index 6c0f0542e0c2c..ea33e2c12da61 100644 --- a/compiler/rustc_incremental/src/assert_dep_graph.rs +++ b/compiler/rustc_incremental/src/assert_dep_graph.rs @@ -172,7 +172,7 @@ impl Visitor<'tcx> for IfThisChanged<'tcx> { } fn visit_trait_item(&mut self, trait_item: &'tcx hir::TraitItem<'tcx>) { - self.process_attrs(trait_item.hir_id, &trait_item.attrs); + self.process_attrs(trait_item.hir_id(), &trait_item.attrs); intravisit::walk_trait_item(self, trait_item); } diff --git a/compiler/rustc_incremental/src/persist/dirty_clean.rs b/compiler/rustc_incremental/src/persist/dirty_clean.rs index 518ab78ea68b4..f6cc70969c2d2 100644 --- a/compiler/rustc_incremental/src/persist/dirty_clean.rs +++ b/compiler/rustc_incremental/src/persist/dirty_clean.rs @@ -454,7 +454,7 @@ impl ItemLikeVisitor<'tcx> for DirtyCleanVisitor<'tcx> { } fn visit_trait_item(&mut self, item: &hir::TraitItem<'_>) { - self.check_item(item.hir_id, item.span); + self.check_item(item.hir_id(), item.span); } fn visit_impl_item(&mut self, item: &hir::ImplItem<'_>) { diff --git a/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/static_impl_trait.rs b/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/static_impl_trait.rs index cf669d37dcff9..aab6883637555 100644 --- a/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/static_impl_trait.rs +++ b/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/static_impl_trait.rs @@ -8,8 +8,7 @@ use rustc_errors::{struct_span_err, Applicability, DiagnosticBuilder, ErrorRepor use rustc_hir::def_id::DefId; use rustc_hir::intravisit::{walk_ty, ErasedMap, NestedVisitorMap, Visitor}; use rustc_hir::{ - self as hir, GenericBound, ImplItem, Item, ItemKind, Lifetime, LifetimeName, Node, TraitItem, - TyKind, + self as hir, GenericBound, ImplItem, Item, ItemKind, Lifetime, LifetimeName, Node, TyKind, }; use rustc_middle::ty::{self, AssocItemContainer, RegionKind, Ty, TypeFoldable, TypeVisitor}; use rustc_span::symbol::Ident; @@ -352,8 +351,8 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> { _ => None, } } - Some(Node::TraitItem(TraitItem { ident, hir_id, .. })) => { - let parent_id = tcx.hir().get_parent_item(*hir_id); + Some(Node::TraitItem(trait_item)) => { + let parent_id = tcx.hir().get_parent_item(trait_item.hir_id()); match tcx.hir().find(parent_id) { Some(Node::Item(Item { kind: ItemKind::Trait(..), .. })) => { // The method being called is defined in the `trait`, but the `'static` @@ -389,7 +388,7 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> { }) .next() { - Some(self_ty) => Some((*ident, self_ty)), + Some(self_ty) => Some((trait_item.ident, self_ty)), _ => None, } } diff --git a/compiler/rustc_lint/src/builtin.rs b/compiler/rustc_lint/src/builtin.rs index baab339a3240f..36db31a35dcf9 100644 --- a/compiler/rustc_lint/src/builtin.rs +++ b/compiler/rustc_lint/src/builtin.rs @@ -586,7 +586,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc { if let hir::VisibilityKind::Inherited = it.vis.node { self.private_traits.insert(it.hir_id()); for trait_item_ref in trait_item_refs { - self.private_traits.insert(trait_item_ref.id.hir_id); + self.private_traits.insert(trait_item_ref.id.hir_id()); } return; } @@ -626,16 +626,15 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc { } fn check_trait_item(&mut self, cx: &LateContext<'_>, trait_item: &hir::TraitItem<'_>) { - if self.private_traits.contains(&trait_item.hir_id) { + if self.private_traits.contains(&trait_item.hir_id()) { return; } - let def_id = cx.tcx.hir().local_def_id(trait_item.hir_id); - let (article, desc) = cx.tcx.article_and_description(def_id.to_def_id()); + let (article, desc) = cx.tcx.article_and_description(trait_item.def_id.to_def_id()); self.check_missing_docs_attrs( cx, - Some(trait_item.hir_id), + Some(trait_item.hir_id()), &trait_item.attrs, trait_item.span, article, diff --git a/compiler/rustc_lint/src/late.rs b/compiler/rustc_lint/src/late.rs index 860fa7fd8e39c..927e64706213c 100644 --- a/compiler/rustc_lint/src/late.rs +++ b/compiler/rustc_lint/src/late.rs @@ -301,8 +301,8 @@ impl<'tcx, T: LateLintPass<'tcx>> hir_visit::Visitor<'tcx> for LateContextAndPas fn visit_trait_item(&mut self, trait_item: &'tcx hir::TraitItem<'tcx>) { let generics = self.context.generics.take(); self.context.generics = Some(&trait_item.generics); - self.with_lint_attrs(trait_item.hir_id, &trait_item.attrs, |cx| { - cx.with_param_env(trait_item.hir_id, |cx| { + self.with_lint_attrs(trait_item.hir_id(), &trait_item.attrs, |cx| { + cx.with_param_env(trait_item.hir_id(), |cx| { lint_callback!(cx, check_trait_item, trait_item); hir_visit::walk_trait_item(cx, trait_item); lint_callback!(cx, check_trait_item_post, trait_item); diff --git a/compiler/rustc_lint/src/levels.rs b/compiler/rustc_lint/src/levels.rs index 18ed350e672fb..b765ac08714cf 100644 --- a/compiler/rustc_lint/src/levels.rs +++ b/compiler/rustc_lint/src/levels.rs @@ -631,7 +631,7 @@ impl<'tcx> intravisit::Visitor<'tcx> for LintLevelMapBuilder<'_, 'tcx> { } fn visit_trait_item(&mut self, trait_item: &'tcx hir::TraitItem<'tcx>) { - self.with_lint_attrs(trait_item.hir_id, &trait_item.attrs, |builder| { + self.with_lint_attrs(trait_item.hir_id(), &trait_item.attrs, |builder| { intravisit::walk_trait_item(builder, trait_item); }); } diff --git a/compiler/rustc_middle/src/hir/map/blocks.rs b/compiler/rustc_middle/src/hir/map/blocks.rs index 3f323eb76c45e..0b1fe94cbfe88 100644 --- a/compiler/rustc_middle/src/hir/map/blocks.rs +++ b/compiler/rustc_middle/src/hir/map/blocks.rs @@ -229,7 +229,7 @@ impl<'a> FnLikeNode<'a> { }, Node::TraitItem(ti) => match ti.kind { hir::TraitItemKind::Fn(ref sig, hir::TraitFn::Provided(body)) => { - method(ti.hir_id, ti.ident, sig, None, body, ti.span, &ti.attrs) + method(ti.hir_id(), ti.ident, sig, None, body, ti.span, &ti.attrs) } _ => bug!("trait method FnLikeNode that is not fn-like"), }, diff --git a/compiler/rustc_middle/src/hir/map/collector.rs b/compiler/rustc_middle/src/hir/map/collector.rs index 31446f4ef7d2f..6f9f75a4994c9 100644 --- a/compiler/rustc_middle/src/hir/map/collector.rs +++ b/compiler/rustc_middle/src/hir/map/collector.rs @@ -391,14 +391,10 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> { } fn visit_trait_item(&mut self, ti: &'hir TraitItem<'hir>) { - debug_assert_eq!( - ti.hir_id.owner, - self.definitions.opt_hir_id_to_local_def_id(ti.hir_id).unwrap() - ); - self.with_dep_node_owner(ti.hir_id.owner, ti, |this, hash| { - this.insert_with_hash(ti.span, ti.hir_id, Node::TraitItem(ti), hash); + self.with_dep_node_owner(ti.def_id, ti, |this, hash| { + this.insert_with_hash(ti.span, ti.hir_id(), Node::TraitItem(ti), hash); - this.with_parent(ti.hir_id, |this| { + this.with_parent(ti.hir_id(), |this| { intravisit::walk_trait_item(this, ti); }); }); diff --git a/compiler/rustc_middle/src/hir/map/mod.rs b/compiler/rustc_middle/src/hir/map/mod.rs index 948e6e60c56d5..f9de6cbf93e9d 100644 --- a/compiler/rustc_middle/src/hir/map/mod.rs +++ b/compiler/rustc_middle/src/hir/map/mod.rs @@ -308,7 +308,7 @@ impl<'hir> Map<'hir> { } pub fn trait_item(&self, id: TraitItemId) -> &'hir TraitItem<'hir> { - match self.find(id.hir_id).unwrap() { + match self.find(id.hir_id()).unwrap() { Node::TraitItem(item) => item, _ => bug!(), } diff --git a/compiler/rustc_middle/src/ty/error.rs b/compiler/rustc_middle/src/ty/error.rs index 1669c59d7f1b9..9ee299ac4fb26 100644 --- a/compiler/rustc_middle/src/ty/error.rs +++ b/compiler/rustc_middle/src/ty/error.rs @@ -816,7 +816,7 @@ fn foo(&self) -> Self::T { String::new() } // an assoc type as a return type (#72076). if let hir::Defaultness::Default { has_value: true } = item.defaultness { - if self.type_of(self.hir().local_def_id(item.id.hir_id)) == found { + if self.type_of(item.id.def_id) == found { db.span_label( item.span, "associated type defaults can't be assumed inside the \ diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs index 3c12f64ed21be..0552ad7389186 100644 --- a/compiler/rustc_passes/src/check_attr.rs +++ b/compiler/rustc_passes/src/check_attr.rs @@ -1081,7 +1081,13 @@ impl Visitor<'tcx> for CheckAttrVisitor<'tcx> { fn visit_trait_item(&mut self, trait_item: &'tcx TraitItem<'tcx>) { let target = Target::from_trait_item(trait_item); - self.check_attributes(trait_item.hir_id, &trait_item.attrs, &trait_item.span, target, None); + self.check_attributes( + trait_item.hir_id(), + &trait_item.attrs, + &trait_item.span, + target, + None, + ); intravisit::walk_trait_item(self, trait_item) } diff --git a/compiler/rustc_passes/src/dead.rs b/compiler/rustc_passes/src/dead.rs index 559fd4d6ea573..bdf3343811635 100644 --- a/compiler/rustc_passes/src/dead.rs +++ b/compiler/rustc_passes/src/dead.rs @@ -440,9 +440,9 @@ impl<'v, 'k, 'tcx> ItemLikeVisitor<'v> for LifeSeeder<'k, 'tcx> { fn visit_trait_item(&mut self, trait_item: &hir::TraitItem<'_>) { use hir::TraitItemKind::{Const, Fn}; if matches!(trait_item.kind, Const(_, Some(_)) | Fn(_, hir::TraitFn::Provided(_))) - && has_allow_dead_code_or_lang_attr(self.tcx, trait_item.hir_id, &trait_item.attrs) + && has_allow_dead_code_or_lang_attr(self.tcx, trait_item.hir_id(), &trait_item.attrs) { - self.worklist.push(trait_item.hir_id); + self.worklist.push(trait_item.hir_id()); } } diff --git a/compiler/rustc_passes/src/diagnostic_items.rs b/compiler/rustc_passes/src/diagnostic_items.rs index 919dc8864dcb9..ded5fa1e57b3a 100644 --- a/compiler/rustc_passes/src/diagnostic_items.rs +++ b/compiler/rustc_passes/src/diagnostic_items.rs @@ -31,7 +31,7 @@ impl<'v, 'tcx> ItemLikeVisitor<'v> for DiagnosticItemCollector<'tcx> { } fn visit_trait_item(&mut self, trait_item: &hir::TraitItem<'_>) { - self.observe_item(&trait_item.attrs, trait_item.hir_id); + self.observe_item(&trait_item.attrs, trait_item.hir_id()); } fn visit_impl_item(&mut self, impl_item: &hir::ImplItem<'_>) { diff --git a/compiler/rustc_passes/src/hir_id_validator.rs b/compiler/rustc_passes/src/hir_id_validator.rs index 4e3010777c1ef..3c83fdfa11bd6 100644 --- a/compiler/rustc_passes/src/hir_id_validator.rs +++ b/compiler/rustc_passes/src/hir_id_validator.rs @@ -61,7 +61,7 @@ impl<'a, 'hir> ItemLikeVisitor<'hir> for OuterVisitor<'a, 'hir> { fn visit_trait_item(&mut self, i: &'hir hir::TraitItem<'hir>) { let mut inner_visitor = self.new_inner_visitor(self.hir_map); - inner_visitor.check(i.hir_id, |this| intravisit::walk_trait_item(this, i)); + inner_visitor.check(i.hir_id(), |this| intravisit::walk_trait_item(this, i)); } fn visit_impl_item(&mut self, i: &'hir hir::ImplItem<'hir>) { diff --git a/compiler/rustc_passes/src/hir_stats.rs b/compiler/rustc_passes/src/hir_stats.rs index cf29a55bee0d7..0db8481b82494 100644 --- a/compiler/rustc_passes/src/hir_stats.rs +++ b/compiler/rustc_passes/src/hir_stats.rs @@ -187,7 +187,7 @@ impl<'v> hir_visit::Visitor<'v> for StatCollector<'v> { } fn visit_trait_item(&mut self, ti: &'v hir::TraitItem<'v>) { - self.record("TraitItem", Id::Node(ti.hir_id), ti); + self.record("TraitItem", Id::Node(ti.hir_id()), ti); hir_visit::walk_trait_item(self, ti) } diff --git a/compiler/rustc_passes/src/lang_items.rs b/compiler/rustc_passes/src/lang_items.rs index a81ee22e464c2..84e1444b4cc4c 100644 --- a/compiler/rustc_passes/src/lang_items.rs +++ b/compiler/rustc_passes/src/lang_items.rs @@ -42,7 +42,7 @@ impl ItemLikeVisitor<'v> for LanguageItemCollector<'tcx> { fn visit_trait_item(&mut self, trait_item: &hir::TraitItem<'_>) { self.check_for_lang( Target::from_trait_item(trait_item), - trait_item.hir_id, + trait_item.hir_id(), trait_item.attrs, ) } diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs index c99784f827902..7782b02985683 100644 --- a/compiler/rustc_passes/src/stability.rs +++ b/compiler/rustc_passes/src/stability.rs @@ -389,7 +389,7 @@ impl<'a, 'tcx> Visitor<'tcx> for Annotator<'a, 'tcx> { fn visit_trait_item(&mut self, ti: &'tcx hir::TraitItem<'tcx>) { self.annotate( - ti.hir_id, + ti.hir_id(), &ti.attrs, ti.span, AnnotationKind::Required, @@ -571,7 +571,7 @@ impl<'tcx> Visitor<'tcx> for MissingStabilityAnnotations<'tcx> { } fn visit_trait_item(&mut self, ti: &'tcx hir::TraitItem<'tcx>) { - self.check_missing_stability(ti.hir_id, ti.span); + self.check_missing_stability(ti.hir_id(), ti.span); intravisit::walk_trait_item(self, ti); } diff --git a/compiler/rustc_privacy/src/lib.rs b/compiler/rustc_privacy/src/lib.rs index d79e9cf505b36..3c0e85eb7b909 100644 --- a/compiler/rustc_privacy/src/lib.rs +++ b/compiler/rustc_privacy/src/lib.rs @@ -669,7 +669,7 @@ impl Visitor<'tcx> for EmbargoVisitor<'tcx> { } hir::ItemKind::Trait(.., trait_item_refs) => { for trait_item_ref in trait_item_refs { - self.update(trait_item_ref.id.hir_id, item_level); + self.update(trait_item_ref.id.hir_id(), item_level); } } hir::ItemKind::Struct(ref def, _) | hir::ItemKind::Union(ref def, _) => { @@ -745,7 +745,7 @@ impl Visitor<'tcx> for EmbargoVisitor<'tcx> { self.reach(item.hir_id(), item_level).generics().predicates(); for trait_item_ref in trait_item_refs { - let mut reach = self.reach(trait_item_ref.id.hir_id, item_level); + let mut reach = self.reach(trait_item_ref.id.hir_id(), item_level); reach.generics().predicates(); if trait_item_ref.kind == AssocItemKind::Type @@ -1954,14 +1954,14 @@ impl<'a, 'tcx> Visitor<'tcx> for PrivateItemsInPublicInterfacesVisitor<'a, 'tcx> for trait_item_ref in trait_item_refs { self.check_assoc_item( - trait_item_ref.id.hir_id, + trait_item_ref.id.hir_id(), trait_item_ref.kind, trait_item_ref.defaultness, item_visibility, ); if let AssocItemKind::Type = trait_item_ref.kind { - self.check(trait_item_ref.id.hir_id, item_visibility).bounds(); + self.check(trait_item_ref.id.hir_id(), item_visibility).bounds(); } } } diff --git a/compiler/rustc_resolve/src/late/lifetimes.rs b/compiler/rustc_resolve/src/late/lifetimes.rs index fa8af36ec211e..2c5e7f7c212fe 100644 --- a/compiler/rustc_resolve/src/late/lifetimes.rs +++ b/compiler/rustc_resolve/src/late/lifetimes.rs @@ -635,7 +635,8 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> { let parent_item_id = hir::ItemId { def_id: parent_id.expect_owner() }; let parent_impl_id = hir::ImplItemId { hir_id: parent_id }; - let parent_trait_id = hir::TraitItemId { hir_id: parent_id }; + let parent_trait_id = + hir::TraitItemId { def_id: parent_id.expect_owner() }; let krate = self.tcx.hir().krate(); if !(krate.items.contains_key(&parent_item_id) @@ -740,7 +741,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> { self.missing_named_lifetime_spots.push((&trait_item.generics).into()); let tcx = self.tcx; self.visit_early_late( - Some(tcx.hir().get_parent_item(trait_item.hir_id)), + Some(tcx.hir().get_parent_item(trait_item.hir_id())), &sig.decl, &trait_item.generics, |this| intravisit::walk_trait_item(this, trait_item), @@ -2113,7 +2114,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { self.tcx.hir().expect_item(self.tcx.hir().get_parent_item(parent)).kind { assoc_item_kind = - trait_items.iter().find(|ti| ti.id.hir_id == parent).map(|ti| ti.kind); + trait_items.iter().find(|ti| ti.id.hir_id() == parent).map(|ti| ti.kind); } match *m { hir::TraitFn::Required(_) => None, diff --git a/compiler/rustc_save_analysis/src/dump_visitor.rs b/compiler/rustc_save_analysis/src/dump_visitor.rs index 1d807dd917c57..4a58dfd429464 100644 --- a/compiler/rustc_save_analysis/src/dump_visitor.rs +++ b/compiler/rustc_save_analysis/src/dump_visitor.rs @@ -674,7 +674,7 @@ impl<'tcx> DumpVisitor<'tcx> { let id = id_from_def_id(item.def_id.to_def_id()); let span = self.span_from_span(item.ident.span); let children = - methods.iter().map(|i| id_from_hir_id(i.id.hir_id, &self.save_ctxt)).collect(); + methods.iter().map(|i| id_from_def_id(i.id.def_id.to_def_id())).collect(); self.dumper.dump_def( &access_from!(self.save_ctxt, item, item.hir_id()), Def { @@ -999,7 +999,7 @@ impl<'tcx> DumpVisitor<'tcx> { let body = body.map(|b| &self.tcx.hir().body(b).value); let respan = respan(vis_span, hir::VisibilityKind::Public); self.process_assoc_const( - trait_item.hir_id, + trait_item.hir_id(), trait_item.ident, &ty, body, @@ -1015,7 +1015,7 @@ impl<'tcx> DumpVisitor<'tcx> { self.process_method( sig, body, - trait_item.hir_id, + trait_item.hir_id(), trait_item.ident, &trait_item.generics, &respan, @@ -1025,15 +1025,12 @@ impl<'tcx> DumpVisitor<'tcx> { hir::TraitItemKind::Type(ref bounds, ref default_ty) => { // FIXME do something with _bounds (for type refs) let name = trait_item.ident.name.to_string(); - let qualname = format!( - "::{}", - self.tcx - .def_path_str(self.tcx.hir().local_def_id(trait_item.hir_id).to_def_id()) - ); + let qualname = + format!("::{}", self.tcx.def_path_str(trait_item.def_id.to_def_id())); if !self.span.filter_generated(trait_item.ident.span) { let span = self.span_from_span(trait_item.ident.span); - let id = id_from_hir_id(trait_item.hir_id, &self.save_ctxt); + let id = id_from_def_id(trait_item.def_id.to_def_id()); self.dumper.dump_def( &Access { public: true, reachable: true }, @@ -1049,7 +1046,7 @@ impl<'tcx> DumpVisitor<'tcx> { decl_id: None, docs: self.save_ctxt.docs_for_attrs(&trait_item.attrs), sig: sig::assoc_type_signature( - trait_item.hir_id, + trait_item.hir_id(), trait_item.ident, Some(bounds), default_ty.as_ref().map(|ty| &**ty), diff --git a/compiler/rustc_symbol_mangling/src/test.rs b/compiler/rustc_symbol_mangling/src/test.rs index 1a3b89302bb43..7a667a127d3ca 100644 --- a/compiler/rustc_symbol_mangling/src/test.rs +++ b/compiler/rustc_symbol_mangling/src/test.rs @@ -65,7 +65,7 @@ impl hir::itemlikevisit::ItemLikeVisitor<'tcx> for SymbolNamesTest<'tcx> { } fn visit_trait_item(&mut self, trait_item: &'tcx hir::TraitItem<'tcx>) { - self.process_attrs(trait_item.hir_id); + self.process_attrs(trait_item.hir_id()); } fn visit_impl_item(&mut self, impl_item: &'tcx hir::ImplItem<'tcx>) { diff --git a/compiler/rustc_ty_utils/src/ty.rs b/compiler/rustc_ty_utils/src/ty.rs index 77aa441340912..d89c8e8121861 100644 --- a/compiler/rustc_ty_utils/src/ty.rs +++ b/compiler/rustc_ty_utils/src/ty.rs @@ -82,7 +82,7 @@ fn associated_item_from_trait_item_ref( parent_def_id: LocalDefId, trait_item_ref: &hir::TraitItemRef, ) -> ty::AssocItem { - let def_id = tcx.hir().local_def_id(trait_item_ref.id.hir_id); + let def_id = trait_item_ref.id.def_id; let (kind, has_self) = match trait_item_ref.kind { hir::AssocItemKind::Const => (ty::AssocKind::Const, false), hir::AssocItemKind::Fn { has_self } => (ty::AssocKind::Fn, has_self), @@ -139,7 +139,9 @@ fn associated_item(tcx: TyCtxt<'_>, def_id: DefId) -> ty::AssocItem { } hir::ItemKind::Trait(.., ref trait_item_refs) => { - if let Some(trait_item_ref) = trait_item_refs.iter().find(|i| i.id.hir_id == id) { + if let Some(trait_item_ref) = + trait_item_refs.iter().find(|i| i.id.def_id.to_def_id() == def_id) + { let assoc_item = associated_item_from_trait_item_ref(tcx, parent_def_id, trait_item_ref); debug_assert_eq!(assoc_item.def_id, def_id); @@ -196,10 +198,7 @@ fn associated_item_def_ids(tcx: TyCtxt<'_>, def_id: DefId) -> &[DefId] { let item = tcx.hir().expect_item(id); match item.kind { hir::ItemKind::Trait(.., ref trait_item_refs) => tcx.arena.alloc_from_iter( - trait_item_refs - .iter() - .map(|trait_item_ref| trait_item_ref.id) - .map(|id| tcx.hir().local_def_id(id.hir_id).to_def_id()), + trait_item_refs.iter().map(|trait_item_ref| trait_item_ref.id.def_id.to_def_id()), ), hir::ItemKind::Impl(ref impl_) => tcx.arena.alloc_from_iter( impl_ diff --git a/compiler/rustc_typeck/src/check/check.rs b/compiler/rustc_typeck/src/check/check.rs index 99afaf3466210..8c33abd45edc7 100644 --- a/compiler/rustc_typeck/src/check/check.rs +++ b/compiler/rustc_typeck/src/check/check.rs @@ -725,8 +725,7 @@ pub fn check_item_type<'tcx>(tcx: TyCtxt<'tcx>, it: &'tcx hir::Item<'tcx>) { fn_maybe_err(tcx, item.ident.span, abi); } hir::TraitItemKind::Type(.., Some(_default)) => { - let item_def_id = tcx.hir().local_def_id(item.hir_id).to_def_id(); - let assoc_item = tcx.associated_item(item_def_id); + let assoc_item = tcx.associated_item(item.def_id); let trait_substs = InternalSubsts::identity_for_item(tcx, it.def_id.to_def_id()); let _: Result<_, rustc_errors::ErrorReported> = check_type_bounds( diff --git a/compiler/rustc_typeck/src/check/compare_method.rs b/compiler/rustc_typeck/src/check/compare_method.rs index d37d6bc4f2df6..5f4db8cc989fb 100644 --- a/compiler/rustc_typeck/src/check/compare_method.rs +++ b/compiler/rustc_typeck/src/check/compare_method.rs @@ -823,8 +823,8 @@ fn compare_synthetic_generics<'tcx>( // FIXME: this is obviously suboptimal since the name can already be used // as another generic argument let new_name = tcx.sess.source_map().span_to_snippet(trait_span).ok()?; - let trait_m = tcx.hir().local_def_id_to_hir_id(trait_m.def_id.as_local()?); - let trait_m = tcx.hir().trait_item(hir::TraitItemId { hir_id: trait_m }); + let trait_m = trait_m.def_id.as_local()?; + let trait_m = tcx.hir().trait_item(hir::TraitItemId { def_id: trait_m }); let impl_m = tcx.hir().local_def_id_to_hir_id(impl_m.def_id.as_local()?); let impl_m = tcx.hir().impl_item(hir::ImplItemId { hir_id: impl_m }); diff --git a/compiler/rustc_typeck/src/check/wfcheck.rs b/compiler/rustc_typeck/src/check/wfcheck.rs index fbb5b2d42e939..b9a96fcfb6f92 100644 --- a/compiler/rustc_typeck/src/check/wfcheck.rs +++ b/compiler/rustc_typeck/src/check/wfcheck.rs @@ -197,7 +197,7 @@ pub fn check_trait_item(tcx: TyCtxt<'_>, def_id: LocalDefId) { _ => None, }; check_object_unsafe_self_trait_by_name(tcx, &trait_item); - check_associated_item(tcx, trait_item.hir_id, trait_item.span, method_sig); + check_associated_item(tcx, trait_item.hir_id(), trait_item.span, method_sig); } fn could_be_self(trait_def_id: LocalDefId, ty: &hir::Ty<'_>) -> bool { @@ -213,7 +213,7 @@ fn could_be_self(trait_def_id: LocalDefId, ty: &hir::Ty<'_>) -> bool { /// Detect when an object unsafe trait is referring to itself in one of its associated items. /// When this is done, suggest using `Self` instead. fn check_object_unsafe_self_trait_by_name(tcx: TyCtxt<'_>, item: &hir::TraitItem<'_>) { - let (trait_name, trait_def_id) = match tcx.hir().get(tcx.hir().get_parent_item(item.hir_id)) { + let (trait_name, trait_def_id) = match tcx.hir().get(tcx.hir().get_parent_item(item.hir_id())) { hir::Node::Item(item) => match item.kind { hir::ItemKind::Trait(..) => (item.ident, item.def_id), _ => return, @@ -1354,8 +1354,7 @@ impl Visitor<'tcx> for CheckTypeWellFormedVisitor<'tcx> { fn visit_trait_item(&mut self, trait_item: &'tcx hir::TraitItem<'tcx>) { debug!("visit_trait_item: {:?}", trait_item); - let def_id = self.tcx.hir().local_def_id(trait_item.hir_id); - self.tcx.ensure().check_trait_item_well_formed(def_id); + self.tcx.ensure().check_trait_item_well_formed(trait_item.def_id); hir_visit::walk_trait_item(self, trait_item); } diff --git a/compiler/rustc_typeck/src/collect.rs b/compiler/rustc_typeck/src/collect.rs index 21c0a2d79c81b..29c18ef4d55f5 100644 --- a/compiler/rustc_typeck/src/collect.rs +++ b/compiler/rustc_typeck/src/collect.rs @@ -281,7 +281,7 @@ impl Visitor<'tcx> for CollectItemTypesVisitor<'tcx> { } fn visit_trait_item(&mut self, trait_item: &'tcx hir::TraitItem<'tcx>) { - convert_trait_item(self.tcx, trait_item.hir_id); + convert_trait_item(self.tcx, trait_item.trait_item_id()); intravisit::walk_trait_item(self, trait_item); } @@ -804,23 +804,22 @@ fn convert_item(tcx: TyCtxt<'_>, item_id: hir::ItemId) { } } -fn convert_trait_item(tcx: TyCtxt<'_>, trait_item_id: hir::HirId) { - let trait_item = tcx.hir().expect_trait_item(trait_item_id); - let def_id = tcx.hir().local_def_id(trait_item.hir_id); - tcx.ensure().generics_of(def_id); +fn convert_trait_item(tcx: TyCtxt<'_>, trait_item_id: hir::TraitItemId) { + let trait_item = tcx.hir().trait_item(trait_item_id); + tcx.ensure().generics_of(trait_item_id.def_id); match trait_item.kind { hir::TraitItemKind::Fn(..) => { - tcx.ensure().type_of(def_id); - tcx.ensure().fn_sig(def_id); + tcx.ensure().type_of(trait_item_id.def_id); + tcx.ensure().fn_sig(trait_item_id.def_id); } hir::TraitItemKind::Const(.., Some(_)) => { - tcx.ensure().type_of(def_id); + tcx.ensure().type_of(trait_item_id.def_id); } hir::TraitItemKind::Const(..) => { - tcx.ensure().type_of(def_id); + tcx.ensure().type_of(trait_item_id.def_id); // Account for `const C: _;`. let mut visitor = PlaceholderHirTyCollector::default(); visitor.visit_trait_item(trait_item); @@ -828,8 +827,8 @@ fn convert_trait_item(tcx: TyCtxt<'_>, trait_item_id: hir::HirId) { } hir::TraitItemKind::Type(_, Some(_)) => { - tcx.ensure().item_bounds(def_id); - tcx.ensure().type_of(def_id); + tcx.ensure().item_bounds(trait_item_id.def_id); + tcx.ensure().type_of(trait_item_id.def_id); // Account for `type T = _;`. let mut visitor = PlaceholderHirTyCollector::default(); visitor.visit_trait_item(trait_item); @@ -837,7 +836,7 @@ fn convert_trait_item(tcx: TyCtxt<'_>, trait_item_id: hir::HirId) { } hir::TraitItemKind::Type(_, None) => { - tcx.ensure().item_bounds(def_id); + tcx.ensure().item_bounds(trait_item_id.def_id); // #74612: Visit and try to find bad placeholders // even if there is no concrete type. let mut visitor = PlaceholderHirTyCollector::default(); @@ -847,7 +846,7 @@ fn convert_trait_item(tcx: TyCtxt<'_>, trait_item_id: hir::HirId) { } }; - tcx.ensure().predicates_of(def_id); + tcx.ensure().predicates_of(trait_item_id.def_id); } fn convert_impl_item(tcx: TyCtxt<'_>, impl_item_id: hir::HirId) { diff --git a/compiler/rustc_typeck/src/collect/type_of.rs b/compiler/rustc_typeck/src/collect/type_of.rs index ca2f6c450ea44..2154280f48fce 100644 --- a/compiler/rustc_typeck/src/collect/type_of.rs +++ b/compiler/rustc_typeck/src/collect/type_of.rs @@ -599,8 +599,7 @@ fn find_opaque_ty_constraints(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Ty<'_> { } fn visit_trait_item(&mut self, it: &'tcx TraitItem<'tcx>) { debug!("find_existential_constraints: visiting {:?}", it); - let def_id = self.tcx.hir().local_def_id(it.hir_id); - self.check(def_id); + self.check(it.def_id); intravisit::walk_trait_item(self, it); } } diff --git a/compiler/rustc_typeck/src/variance/constraints.rs b/compiler/rustc_typeck/src/variance/constraints.rs index d66508e5b7f19..570504aa6270b 100644 --- a/compiler/rustc_typeck/src/variance/constraints.rs +++ b/compiler/rustc_typeck/src/variance/constraints.rs @@ -98,7 +98,7 @@ impl<'a, 'tcx, 'v> ItemLikeVisitor<'v> for ConstraintContext<'a, 'tcx> { fn visit_trait_item(&mut self, trait_item: &hir::TraitItem<'_>) { if let hir::TraitItemKind::Fn(..) = trait_item.kind { - self.visit_node_helper(trait_item.hir_id); + self.visit_node_helper(trait_item.hir_id()); } } diff --git a/compiler/rustc_typeck/src/variance/terms.rs b/compiler/rustc_typeck/src/variance/terms.rs index acedce4d2d422..9ff52c0d226d9 100644 --- a/compiler/rustc_typeck/src/variance/terms.rs +++ b/compiler/rustc_typeck/src/variance/terms.rs @@ -159,7 +159,7 @@ impl<'a, 'tcx, 'v> ItemLikeVisitor<'v> for TermsContext<'a, 'tcx> { fn visit_trait_item(&mut self, trait_item: &hir::TraitItem<'_>) { if let hir::TraitItemKind::Fn(..) = trait_item.kind { - self.add_inferreds_for_item(trait_item.hir_id); + self.add_inferreds_for_item(trait_item.hir_id()); } } diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 411287de23f50..c20d3eda858d8 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -1044,7 +1044,7 @@ impl Clean for hir::def::DefKind { impl Clean for hir::TraitItem<'_> { fn clean(&self, cx: &DocContext<'_>) -> Item { - let local_did = cx.tcx.hir().local_def_id(self.hir_id).to_def_id(); + let local_did = self.def_id.to_def_id(); cx.with_param_env(local_did, || { let inner = match self.kind { hir::TraitItemKind::Const(ref ty, default) => { diff --git a/src/librustdoc/doctest.rs b/src/librustdoc/doctest.rs index 10015afb166fd..5df2a293ea24e 100644 --- a/src/librustdoc/doctest.rs +++ b/src/librustdoc/doctest.rs @@ -1056,9 +1056,15 @@ impl<'a, 'hir, 'tcx> intravisit::Visitor<'hir> for HirCollector<'a, 'hir, 'tcx> } fn visit_trait_item(&mut self, item: &'hir hir::TraitItem<'_>) { - self.visit_testable(item.ident.to_string(), &item.attrs, item.hir_id, item.span, |this| { - intravisit::walk_trait_item(this, item); - }); + self.visit_testable( + item.ident.to_string(), + &item.attrs, + item.hir_id(), + item.span, + |this| { + intravisit::walk_trait_item(this, item); + }, + ); } fn visit_impl_item(&mut self, item: &'hir hir::ImplItem<'_>) { diff --git a/src/tools/clippy/clippy_lints/src/doc.rs b/src/tools/clippy/clippy_lints/src/doc.rs index c12448588891a..8a82b550bdae6 100644 --- a/src/tools/clippy/clippy_lints/src/doc.rs +++ b/src/tools/clippy/clippy_lints/src/doc.rs @@ -246,7 +246,7 @@ impl<'tcx> LateLintPass<'tcx> for DocMarkdown { let headers = check_attrs(cx, &self.valid_idents, &item.attrs); if let hir::TraitItemKind::Fn(ref sig, ..) = item.kind { if !in_external_macro(cx.tcx.sess, item.span) { - lint_for_missing_headers(cx, item.hir_id, item.span, sig, headers, None, None); + lint_for_missing_headers(cx, item.hir_id(), item.span, sig, headers, None, None); } } } diff --git a/src/tools/clippy/clippy_lints/src/escape.rs b/src/tools/clippy/clippy_lints/src/escape.rs index 40e93da8dffb4..f8ef2a464d5c3 100644 --- a/src/tools/clippy/clippy_lints/src/escape.rs +++ b/src/tools/clippy/clippy_lints/src/escape.rs @@ -87,11 +87,11 @@ impl<'tcx> LateLintPass<'tcx> for BoxedLocal { // find `self` ty for this trait if relevant if let ItemKind::Trait(_, _, _, _, items) = item.kind { for trait_item in items { - if trait_item.id.hir_id == hir_id { + if trait_item.id.hir_id() == hir_id { // be sure we have `self` parameter in this function if let AssocItemKind::Fn { has_self: true } = trait_item.kind { trait_self_ty = - Some(TraitRef::identity(cx.tcx, trait_item.id.hir_id.owner.to_def_id()).self_ty()); + Some(TraitRef::identity(cx.tcx, trait_item.id.def_id.to_def_id()).self_ty()); } } } diff --git a/src/tools/clippy/clippy_lints/src/functions.rs b/src/tools/clippy/clippy_lints/src/functions.rs index 28d025315cfeb..eabc745a7b07e 100644 --- a/src/tools/clippy/clippy_lints/src/functions.rs +++ b/src/tools/clippy/clippy_lints/src/functions.rs @@ -339,7 +339,7 @@ impl<'tcx> LateLintPass<'tcx> for Functions { if sig.header.abi == Abi::Rust { self.check_arg_number(cx, &sig.decl, item.span.with_hi(sig.decl.output.span().hi())); } - let is_public = cx.access_levels.is_exported(item.hir_id); + let is_public = cx.access_levels.is_exported(item.hir_id()); let fn_header_span = item.span.with_hi(sig.decl.output.span().hi()); if is_public { check_result_unit_err(cx, &sig.decl, item.span, fn_header_span); @@ -347,11 +347,11 @@ impl<'tcx> LateLintPass<'tcx> for Functions { let attr = must_use_attr(&item.attrs); if let Some(attr) = attr { - check_needless_must_use(cx, &sig.decl, item.hir_id, item.span, fn_header_span, attr); + check_needless_must_use(cx, &sig.decl, item.hir_id(), item.span, fn_header_span, attr); } if let hir::TraitFn::Provided(eid) = *eid { let body = cx.tcx.hir().body(eid); - Self::check_raw_ptr(cx, sig.header.unsafety, &sig.decl, body, item.hir_id); + Self::check_raw_ptr(cx, sig.header.unsafety, &sig.decl, body, item.hir_id()); if attr.is_none() && is_public && !is_proc_macro(cx.sess(), &item.attrs) { check_must_use_candidate( @@ -359,7 +359,7 @@ impl<'tcx> LateLintPass<'tcx> for Functions { &sig.decl, body, item.span, - item.hir_id, + item.hir_id(), item.span.with_hi(sig.decl.output.span().hi()), "this method could have a `#[must_use]` attribute", ); diff --git a/src/tools/clippy/clippy_lints/src/len_zero.rs b/src/tools/clippy/clippy_lints/src/len_zero.rs index 8706cf7f02b92..a89941ceb226b 100644 --- a/src/tools/clippy/clippy_lints/src/len_zero.rs +++ b/src/tools/clippy/clippy_lints/src/len_zero.rs @@ -159,10 +159,7 @@ fn check_trait_items(cx: &LateContext<'_>, visited_trait: &Item<'_>, trait_items fn is_named_self(cx: &LateContext<'_>, item: &TraitItemRef, name: &str) -> bool { item.ident.name.as_str() == name && if let AssocItemKind::Fn { has_self } = item.kind { - has_self && { - let did = cx.tcx.hir().local_def_id(item.id.hir_id); - cx.tcx.fn_sig(did).inputs().skip_binder().len() == 1 - } + has_self && { cx.tcx.fn_sig(item.id.def_id).inputs().skip_binder().len() == 1 } } else { false } diff --git a/src/tools/clippy/clippy_lints/src/methods/mod.rs b/src/tools/clippy/clippy_lints/src/methods/mod.rs index a2104b48b4ffd..a68775ffb7541 100644 --- a/src/tools/clippy/clippy_lints/src/methods/mod.rs +++ b/src/tools/clippy/clippy_lints/src/methods/mod.rs @@ -1791,7 +1791,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods { if let Some(first_arg_ty) = sig.decl.inputs.iter().next(); let first_arg_span = first_arg_ty.span; let first_arg_ty = hir_ty_to_ty(cx.tcx, first_arg_ty); - let self_ty = TraitRef::identity(cx.tcx, item.hir_id.owner.to_def_id()).self_ty(); + let self_ty = TraitRef::identity(cx.tcx, item.def_id.to_def_id()).self_ty(); then { lint_wrong_self_convention(cx, &item.ident.name.as_str(), false, self_ty, first_arg_ty, first_arg_span); @@ -1801,8 +1801,8 @@ impl<'tcx> LateLintPass<'tcx> for Methods { if_chain! { if item.ident.name == sym::new; if let TraitItemKind::Fn(_, _) = item.kind; - let ret_ty = return_ty(cx, item.hir_id); - let self_ty = TraitRef::identity(cx.tcx, item.hir_id.owner.to_def_id()).self_ty(); + let ret_ty = return_ty(cx, item.hir_id()); + let self_ty = TraitRef::identity(cx.tcx, item.def_id.to_def_id()).self_ty(); if !contains_ty(ret_ty, self_ty); then { diff --git a/src/tools/clippy/clippy_lints/src/missing_doc.rs b/src/tools/clippy/clippy_lints/src/missing_doc.rs index 21b59fba995fc..5fce322933e98 100644 --- a/src/tools/clippy/clippy_lints/src/missing_doc.rs +++ b/src/tools/clippy/clippy_lints/src/missing_doc.rs @@ -164,8 +164,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc { } fn check_trait_item(&mut self, cx: &LateContext<'tcx>, trait_item: &'tcx hir::TraitItem<'_>) { - let def_id = cx.tcx.hir().local_def_id(trait_item.hir_id); - let (article, desc) = cx.tcx.article_and_description(def_id.to_def_id()); + let (article, desc) = cx.tcx.article_and_description(trait_item.def_id.to_def_id()); self.check_missing_docs_attrs(cx, &trait_item.attrs, trait_item.span, article, desc); } diff --git a/src/tools/clippy/clippy_lints/src/mut_key.rs b/src/tools/clippy/clippy_lints/src/mut_key.rs index 7b9205a99de1b..16981946e18e7 100644 --- a/src/tools/clippy/clippy_lints/src/mut_key.rs +++ b/src/tools/clippy/clippy_lints/src/mut_key.rs @@ -71,7 +71,7 @@ impl<'tcx> LateLintPass<'tcx> for MutableKeyType { fn check_trait_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::TraitItem<'tcx>) { if let hir::TraitItemKind::Fn(ref sig, ..) = item.kind { - check_sig(cx, item.hir_id, &sig.decl); + check_sig(cx, item.hir_id(), &sig.decl); } } diff --git a/src/tools/clippy/clippy_lints/src/pass_by_ref_or_value.rs b/src/tools/clippy/clippy_lints/src/pass_by_ref_or_value.rs index d96a9b025f089..b9ba32001b513 100644 --- a/src/tools/clippy/clippy_lints/src/pass_by_ref_or_value.rs +++ b/src/tools/clippy/clippy_lints/src/pass_by_ref_or_value.rs @@ -206,7 +206,7 @@ impl<'tcx> LateLintPass<'tcx> for PassByRefOrValue { } if let hir::TraitItemKind::Fn(method_sig, _) = &item.kind { - self.check_poly_fn(cx, item.hir_id, &*method_sig.decl, None); + self.check_poly_fn(cx, item.hir_id(), &*method_sig.decl, None); } } diff --git a/src/tools/clippy/clippy_lints/src/ptr.rs b/src/tools/clippy/clippy_lints/src/ptr.rs index 9efeac3d82383..ee4ad086eb9a2 100644 --- a/src/tools/clippy/clippy_lints/src/ptr.rs +++ b/src/tools/clippy/clippy_lints/src/ptr.rs @@ -147,7 +147,7 @@ impl<'tcx> LateLintPass<'tcx> for Ptr { } else { None }; - check_fn(cx, &sig.decl, item.hir_id, body_id); + check_fn(cx, &sig.decl, item.hir_id(), body_id); } } From 786a80e9ea7af4909f67207c542eb02727f74756 Mon Sep 17 00:00:00 2001 From: Camille GILLOT Date: Sat, 30 Jan 2021 23:25:03 +0100 Subject: [PATCH 07/14] Only store a LocalDefId in hir::ImplItem. --- compiler/rustc_ast_lowering/src/item.rs | 6 ++-- compiler/rustc_hir/src/hir.rs | 29 +++++++++++++++---- compiler/rustc_hir/src/intravisit.rs | 8 ++--- compiler/rustc_hir/src/stable_hash_impls.rs | 10 +++---- compiler/rustc_hir_pretty/src/lib.rs | 4 +-- .../rustc_incremental/src/assert_dep_graph.rs | 2 +- .../src/persist/dirty_clean.rs | 2 +- .../nice_region_error/static_impl_trait.rs | 10 +++---- compiler/rustc_lint/src/builtin.rs | 11 ++++--- compiler/rustc_lint/src/late.rs | 4 +-- compiler/rustc_lint/src/levels.rs | 2 +- compiler/rustc_middle/src/hir/map/blocks.rs | 2 +- .../rustc_middle/src/hir/map/collector.rs | 10 ++----- compiler/rustc_middle/src/hir/map/mod.rs | 2 +- compiler/rustc_middle/src/ty/error.rs | 2 +- .../rustc_mir/src/monomorphize/collector.rs | 3 +- compiler/rustc_passes/src/check_attr.rs | 4 +-- compiler/rustc_passes/src/dead.rs | 12 ++++---- compiler/rustc_passes/src/diagnostic_items.rs | 2 +- compiler/rustc_passes/src/hir_id_validator.rs | 2 +- compiler/rustc_passes/src/hir_stats.rs | 2 +- compiler/rustc_passes/src/lang_items.rs | 2 +- compiler/rustc_passes/src/reachable.rs | 7 ++--- compiler/rustc_passes/src/stability.rs | 6 ++-- compiler/rustc_privacy/src/lib.rs | 24 +++++++-------- compiler/rustc_resolve/src/late/lifetimes.rs | 7 +++-- .../rustc_save_analysis/src/dump_visitor.rs | 4 +-- compiler/rustc_save_analysis/src/lib.rs | 2 +- compiler/rustc_symbol_mangling/src/test.rs | 2 +- compiler/rustc_ty_utils/src/ty.rs | 12 ++++---- compiler/rustc_typeck/src/check/check.rs | 2 +- .../rustc_typeck/src/check/compare_method.rs | 8 ++--- compiler/rustc_typeck/src/check/wfcheck.rs | 5 ++-- compiler/rustc_typeck/src/collect.rs | 8 ++--- compiler/rustc_typeck/src/collect/type_of.rs | 5 ++-- compiler/rustc_typeck/src/impl_wf_check.rs | 2 +- .../rustc_typeck/src/variance/constraints.rs | 2 +- compiler/rustc_typeck/src/variance/terms.rs | 2 +- src/librustdoc/clean/mod.rs | 4 +-- src/librustdoc/doctest.rs | 12 ++++++-- src/tools/clippy/clippy_lints/src/doc.rs | 5 ++-- .../clippy_lints/src/fallible_impl_from.rs | 3 +- .../clippy/clippy_lints/src/functions.rs | 10 +++---- .../clippy_lints/src/inherent_to_string.rs | 7 ++--- src/tools/clippy/clippy_lints/src/len_zero.rs | 9 ++---- .../clippy/clippy_lints/src/lifetimes.rs | 2 +- .../clippy/clippy_lints/src/methods/mod.rs | 9 +++--- .../clippy/clippy_lints/src/missing_doc.rs | 5 ++-- .../clippy/clippy_lints/src/missing_inline.rs | 7 ++--- src/tools/clippy/clippy_lints/src/mut_key.rs | 4 +-- .../clippy_lints/src/new_without_default.rs | 2 +- .../clippy/clippy_lints/src/non_copy_const.rs | 2 +- .../clippy_lints/src/partialeq_ne_impl.rs | 2 +- src/tools/clippy/clippy_lints/src/ptr.rs | 4 +-- .../clippy/clippy_lints/src/unused_self.rs | 5 ++-- .../clippy_lints/src/unwrap_in_result.rs | 7 ++--- 56 files changed, 163 insertions(+), 165 deletions(-) diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs index 192ca79e78006..b80b4a6b9b24b 100644 --- a/compiler/rustc_ast_lowering/src/item.rs +++ b/compiler/rustc_ast_lowering/src/item.rs @@ -98,7 +98,7 @@ impl<'a> Visitor<'a> for ItemLowerer<'a, '_, '_> { } AssocCtxt::Impl => { let hir_item = lctx.lower_impl_item(item); - let id = hir::ImplItemId { hir_id: hir_item.hir_id }; + let id = hir_item.impl_item_id(); lctx.impl_items.insert(id, hir_item); lctx.modules.get_mut(&lctx.current_module).unwrap().impl_items.insert(id); } @@ -931,7 +931,7 @@ impl<'hir> LoweringContext<'_, 'hir> { let has_value = true; let (defaultness, _) = self.lower_defaultness(i.kind.defaultness(), has_value); hir::ImplItem { - hir_id: self.lower_node_id(i.id), + def_id: self.lower_node_id(i.id).expect_owner(), ident: i.ident, attrs: self.lower_attrs(&i.attrs), generics, @@ -947,7 +947,7 @@ impl<'hir> LoweringContext<'_, 'hir> { let has_value = true; let (defaultness, _) = self.lower_defaultness(i.kind.defaultness(), has_value); hir::ImplItemRef { - id: hir::ImplItemId { hir_id: self.lower_node_id(i.id) }, + id: hir::ImplItemId { def_id: self.lower_node_id(i.id).expect_owner() }, ident: i.ident, span: i.span, vis: self.lower_visibility(&i.vis, Some(i.id)), diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs index d47e0a4629ab1..ea23013fa0abd 100644 --- a/compiler/rustc_hir/src/hir.rs +++ b/compiler/rustc_hir/src/hir.rs @@ -1969,14 +1969,21 @@ pub enum TraitItemKind<'hir> { // so it can fetched later. #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Encodable, Debug)] pub struct ImplItemId { - pub hir_id: HirId, + pub def_id: LocalDefId, +} + +impl ImplItemId { + pub fn hir_id(&self) -> HirId { + // Items are always HIR owners. + HirId::make_owner(self.def_id) + } } /// Represents anything within an `impl` block. #[derive(Debug)] pub struct ImplItem<'hir> { pub ident: Ident, - pub hir_id: HirId, + pub def_id: LocalDefId, pub vis: Visibility<'hir>, pub defaultness: Defaultness, pub attrs: &'hir [Attribute], @@ -1985,6 +1992,17 @@ pub struct ImplItem<'hir> { pub span: Span, } +impl ImplItem<'_> { + pub fn hir_id(&self) -> HirId { + // Items are always HIR owners. + HirId::make_owner(self.def_id) + } + + pub fn impl_item_id(&self) -> ImplItemId { + ImplItemId { def_id: self.def_id } + } +} + /// Represents various kinds of content within an `impl`. #[derive(Debug, HashStable_Generic)] pub enum ImplItemKind<'hir> { @@ -2903,11 +2921,10 @@ impl<'hir> Node<'hir> { pub fn hir_id(&self) -> Option { match self { - Node::Item(Item { def_id, .. }) | Node::TraitItem(TraitItem { def_id, .. }) => { - Some(HirId::make_owner(*def_id)) - } + Node::Item(Item { def_id, .. }) + | Node::TraitItem(TraitItem { def_id, .. }) + | Node::ImplItem(ImplItem { def_id, .. }) => Some(HirId::make_owner(*def_id)), Node::ForeignItem(ForeignItem { hir_id, .. }) - | Node::ImplItem(ImplItem { hir_id, .. }) | Node::Field(StructField { hir_id, .. }) | Node::AnonConst(AnonConst { hir_id, .. }) | Node::Expr(Expr { hir_id, .. }) diff --git a/compiler/rustc_hir/src/intravisit.rs b/compiler/rustc_hir/src/intravisit.rs index a145d4dc47688..960a06e043865 100644 --- a/compiler/rustc_hir/src/intravisit.rs +++ b/compiler/rustc_hir/src/intravisit.rs @@ -1004,7 +1004,7 @@ pub fn walk_trait_item_ref<'v, V: Visitor<'v>>(visitor: &mut V, trait_item_ref: pub fn walk_impl_item<'v, V: Visitor<'v>>(visitor: &mut V, impl_item: &'v ImplItem<'v>) { // N.B., deliberately force a compilation error if/when new fields are added. let ImplItem { - hir_id: _, + def_id: _, ident, ref vis, ref defaultness, @@ -1021,7 +1021,7 @@ pub fn walk_impl_item<'v, V: Visitor<'v>>(visitor: &mut V, impl_item: &'v ImplIt visitor.visit_generics(generics); match *kind { ImplItemKind::Const(ref ty, body) => { - visitor.visit_id(impl_item.hir_id); + visitor.visit_id(impl_item.hir_id()); visitor.visit_ty(ty); visitor.visit_nested_body(body); } @@ -1031,11 +1031,11 @@ pub fn walk_impl_item<'v, V: Visitor<'v>>(visitor: &mut V, impl_item: &'v ImplIt &sig.decl, body_id, impl_item.span, - impl_item.hir_id, + impl_item.hir_id(), ); } ImplItemKind::TyAlias(ref ty) => { - visitor.visit_id(impl_item.hir_id); + visitor.visit_id(impl_item.hir_id()); visitor.visit_ty(ty); } } diff --git a/compiler/rustc_hir/src/stable_hash_impls.rs b/compiler/rustc_hir/src/stable_hash_impls.rs index e7e676fe147b9..a344af1237f27 100644 --- a/compiler/rustc_hir/src/stable_hash_impls.rs +++ b/compiler/rustc_hir/src/stable_hash_impls.rs @@ -53,11 +53,11 @@ impl ToStableHashKey for TraitItemId { } impl ToStableHashKey for ImplItemId { - type KeyType = (DefPathHash, ItemLocalId); + type KeyType = DefPathHash; #[inline] - fn to_stable_hash_key(&self, hcx: &HirCtx) -> (DefPathHash, ItemLocalId) { - self.hir_id.to_stable_hash_key(hcx) + fn to_stable_hash_key(&self, hcx: &HirCtx) -> DefPathHash { + hcx.local_def_path_hash(self.def_id) } } @@ -103,7 +103,7 @@ impl HashStable for ForeignItemId { impl HashStable for ImplItemId { fn hash_stable(&self, hcx: &mut HirCtx, hasher: &mut StableHasher) { - hcx.hash_reference_to_item(self.hir_id, hasher) + hcx.hash_reference_to_item(self.hir_id(), hasher) } } @@ -154,7 +154,7 @@ impl HashStable for TraitItem<'_> { impl HashStable for ImplItem<'_> { fn hash_stable(&self, hcx: &mut HirCtx, hasher: &mut StableHasher) { let ImplItem { - hir_id: _, + def_id: _, ident, ref vis, defaultness, diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs index 72a5804f50f7f..02ca42c0f33dd 100644 --- a/compiler/rustc_hir_pretty/src/lib.rs +++ b/compiler/rustc_hir_pretty/src/lib.rs @@ -973,7 +973,7 @@ impl<'a> State<'a> { } pub fn print_impl_item(&mut self, ii: &hir::ImplItem<'_>) { - self.ann.pre(self, AnnNode::SubItem(ii.hir_id)); + self.ann.pre(self, AnnNode::SubItem(ii.hir_id())); self.hardbreak_if_not_bol(); self.maybe_print_comment(ii.span.lo()); self.print_outer_attributes(&ii.attrs); @@ -995,7 +995,7 @@ impl<'a> State<'a> { self.print_associated_type(ii.ident, &ii.generics, None, Some(ty)); } } - self.ann.post(self, AnnNode::SubItem(ii.hir_id)) + self.ann.post(self, AnnNode::SubItem(ii.hir_id())) } pub fn print_local(&mut self, init: Option<&hir::Expr<'_>>, decl: impl Fn(&mut Self)) { diff --git a/compiler/rustc_incremental/src/assert_dep_graph.rs b/compiler/rustc_incremental/src/assert_dep_graph.rs index ea33e2c12da61..1162379d3d981 100644 --- a/compiler/rustc_incremental/src/assert_dep_graph.rs +++ b/compiler/rustc_incremental/src/assert_dep_graph.rs @@ -177,7 +177,7 @@ impl Visitor<'tcx> for IfThisChanged<'tcx> { } fn visit_impl_item(&mut self, impl_item: &'tcx hir::ImplItem<'tcx>) { - self.process_attrs(impl_item.hir_id, &impl_item.attrs); + self.process_attrs(impl_item.hir_id(), &impl_item.attrs); intravisit::walk_impl_item(self, impl_item); } diff --git a/compiler/rustc_incremental/src/persist/dirty_clean.rs b/compiler/rustc_incremental/src/persist/dirty_clean.rs index f6cc70969c2d2..cbe1e29d6d418 100644 --- a/compiler/rustc_incremental/src/persist/dirty_clean.rs +++ b/compiler/rustc_incremental/src/persist/dirty_clean.rs @@ -458,7 +458,7 @@ impl ItemLikeVisitor<'tcx> for DirtyCleanVisitor<'tcx> { } fn visit_impl_item(&mut self, item: &hir::ImplItem<'_>) { - self.check_item(item.hir_id, item.span); + self.check_item(item.hir_id(), item.span); } fn visit_foreign_item(&mut self, item: &hir::ForeignItem<'_>) { diff --git a/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/static_impl_trait.rs b/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/static_impl_trait.rs index aab6883637555..e88c827477e52 100644 --- a/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/static_impl_trait.rs +++ b/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/static_impl_trait.rs @@ -7,9 +7,7 @@ use crate::traits::{ObligationCauseCode, UnifyReceiverContext}; use rustc_errors::{struct_span_err, Applicability, DiagnosticBuilder, ErrorReported}; use rustc_hir::def_id::DefId; use rustc_hir::intravisit::{walk_ty, ErasedMap, NestedVisitorMap, Visitor}; -use rustc_hir::{ - self as hir, GenericBound, ImplItem, Item, ItemKind, Lifetime, LifetimeName, Node, TyKind, -}; +use rustc_hir::{self as hir, GenericBound, Item, ItemKind, Lifetime, LifetimeName, Node, TyKind}; use rustc_middle::ty::{self, AssocItemContainer, RegionKind, Ty, TypeFoldable, TypeVisitor}; use rustc_span::symbol::Ident; use rustc_span::{MultiSpan, Span}; @@ -342,12 +340,12 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> { ) -> Option<(Ident, &'tcx hir::Ty<'tcx>)> { let tcx = self.tcx(); match tcx.hir().get_if_local(def_id) { - Some(Node::ImplItem(ImplItem { ident, hir_id, .. })) => { - match tcx.hir().find(tcx.hir().get_parent_item(*hir_id)) { + Some(Node::ImplItem(impl_item)) => { + match tcx.hir().find(tcx.hir().get_parent_item(impl_item.hir_id())) { Some(Node::Item(Item { kind: ItemKind::Impl(hir::Impl { self_ty, .. }), .. - })) => Some((*ident, self_ty)), + })) => Some((impl_item.ident, self_ty)), _ => None, } } diff --git a/compiler/rustc_lint/src/builtin.rs b/compiler/rustc_lint/src/builtin.rs index 36db31a35dcf9..6ab7089248946 100644 --- a/compiler/rustc_lint/src/builtin.rs +++ b/compiler/rustc_lint/src/builtin.rs @@ -600,7 +600,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc { if let Some(Node::Item(item)) = cx.tcx.hir().find(hir_id) { if let hir::VisibilityKind::Inherited = item.vis.node { for impl_item_ref in items { - self.private_traits.insert(impl_item_ref.id.hir_id); + self.private_traits.insert(impl_item_ref.id.hir_id()); } } } @@ -644,15 +644,14 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc { fn check_impl_item(&mut self, cx: &LateContext<'_>, impl_item: &hir::ImplItem<'_>) { // If the method is an impl for a trait, don't doc. - if method_context(cx, impl_item.hir_id) == MethodLateContext::TraitImpl { + if method_context(cx, impl_item.hir_id()) == MethodLateContext::TraitImpl { return; } - let def_id = cx.tcx.hir().local_def_id(impl_item.hir_id); - let (article, desc) = cx.tcx.article_and_description(def_id.to_def_id()); + let (article, desc) = cx.tcx.article_and_description(impl_item.def_id.to_def_id()); self.check_missing_docs_attrs( cx, - Some(impl_item.hir_id), + Some(impl_item.hir_id()), &impl_item.attrs, impl_item.span, article, @@ -1378,7 +1377,7 @@ impl<'tcx> LateLintPass<'tcx> for UnreachablePub { } fn check_impl_item(&mut self, cx: &LateContext<'_>, impl_item: &hir::ImplItem<'_>) { - self.perform_lint(cx, "item", impl_item.hir_id, &impl_item.vis, impl_item.span, false); + self.perform_lint(cx, "item", impl_item.hir_id(), &impl_item.vis, impl_item.span, false); } } diff --git a/compiler/rustc_lint/src/late.rs b/compiler/rustc_lint/src/late.rs index 927e64706213c..0c4dbd9c47f8c 100644 --- a/compiler/rustc_lint/src/late.rs +++ b/compiler/rustc_lint/src/late.rs @@ -314,8 +314,8 @@ impl<'tcx, T: LateLintPass<'tcx>> hir_visit::Visitor<'tcx> for LateContextAndPas fn visit_impl_item(&mut self, impl_item: &'tcx hir::ImplItem<'tcx>) { let generics = self.context.generics.take(); self.context.generics = Some(&impl_item.generics); - self.with_lint_attrs(impl_item.hir_id, &impl_item.attrs, |cx| { - cx.with_param_env(impl_item.hir_id, |cx| { + self.with_lint_attrs(impl_item.hir_id(), &impl_item.attrs, |cx| { + cx.with_param_env(impl_item.hir_id(), |cx| { lint_callback!(cx, check_impl_item, impl_item); hir_visit::walk_impl_item(cx, impl_item); lint_callback!(cx, check_impl_item_post, impl_item); diff --git a/compiler/rustc_lint/src/levels.rs b/compiler/rustc_lint/src/levels.rs index b765ac08714cf..0b34186bfc1b6 100644 --- a/compiler/rustc_lint/src/levels.rs +++ b/compiler/rustc_lint/src/levels.rs @@ -637,7 +637,7 @@ impl<'tcx> intravisit::Visitor<'tcx> for LintLevelMapBuilder<'_, 'tcx> { } fn visit_impl_item(&mut self, impl_item: &'tcx hir::ImplItem<'tcx>) { - self.with_lint_attrs(impl_item.hir_id, &impl_item.attrs, |builder| { + self.with_lint_attrs(impl_item.hir_id(), &impl_item.attrs, |builder| { intravisit::walk_impl_item(builder, impl_item); }); } diff --git a/compiler/rustc_middle/src/hir/map/blocks.rs b/compiler/rustc_middle/src/hir/map/blocks.rs index 0b1fe94cbfe88..9222ce1015eba 100644 --- a/compiler/rustc_middle/src/hir/map/blocks.rs +++ b/compiler/rustc_middle/src/hir/map/blocks.rs @@ -235,7 +235,7 @@ impl<'a> FnLikeNode<'a> { }, Node::ImplItem(ii) => match ii.kind { hir::ImplItemKind::Fn(ref sig, body) => { - method(ii.hir_id, ii.ident, sig, Some(&ii.vis), body, ii.span, &ii.attrs) + method(ii.hir_id(), ii.ident, sig, Some(&ii.vis), body, ii.span, &ii.attrs) } _ => bug!("impl method FnLikeNode that is not fn-like"), }, diff --git a/compiler/rustc_middle/src/hir/map/collector.rs b/compiler/rustc_middle/src/hir/map/collector.rs index 6f9f75a4994c9..5365f474ec3ee 100644 --- a/compiler/rustc_middle/src/hir/map/collector.rs +++ b/compiler/rustc_middle/src/hir/map/collector.rs @@ -401,14 +401,10 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> { } fn visit_impl_item(&mut self, ii: &'hir ImplItem<'hir>) { - debug_assert_eq!( - ii.hir_id.owner, - self.definitions.opt_hir_id_to_local_def_id(ii.hir_id).unwrap() - ); - self.with_dep_node_owner(ii.hir_id.owner, ii, |this, hash| { - this.insert_with_hash(ii.span, ii.hir_id, Node::ImplItem(ii), hash); + self.with_dep_node_owner(ii.def_id, ii, |this, hash| { + this.insert_with_hash(ii.span, ii.hir_id(), Node::ImplItem(ii), hash); - this.with_parent(ii.hir_id, |this| { + this.with_parent(ii.hir_id(), |this| { intravisit::walk_impl_item(this, ii); }); }); diff --git a/compiler/rustc_middle/src/hir/map/mod.rs b/compiler/rustc_middle/src/hir/map/mod.rs index f9de6cbf93e9d..4ded4171b5efc 100644 --- a/compiler/rustc_middle/src/hir/map/mod.rs +++ b/compiler/rustc_middle/src/hir/map/mod.rs @@ -315,7 +315,7 @@ impl<'hir> Map<'hir> { } pub fn impl_item(&self, id: ImplItemId) -> &'hir ImplItem<'hir> { - match self.find(id.hir_id).unwrap() { + match self.find(id.hir_id()).unwrap() { Node::ImplItem(item) => item, _ => bug!(), } diff --git a/compiler/rustc_middle/src/ty/error.rs b/compiler/rustc_middle/src/ty/error.rs index 9ee299ac4fb26..2b82bace8c057 100644 --- a/compiler/rustc_middle/src/ty/error.rs +++ b/compiler/rustc_middle/src/ty/error.rs @@ -836,7 +836,7 @@ fn foo(&self) -> Self::T { String::new() } })) => { for item in &items[..] { if let hir::AssocItemKind::Type = item.kind { - if self.type_of(self.hir().local_def_id(item.id.hir_id)) == found { + if self.type_of(item.id.def_id) == found { db.span_label(item.span, "expected this associated type"); return true; } diff --git a/compiler/rustc_mir/src/monomorphize/collector.rs b/compiler/rustc_mir/src/monomorphize/collector.rs index b32a8c45f1a5f..20cb989196a98 100644 --- a/compiler/rustc_mir/src/monomorphize/collector.rs +++ b/compiler/rustc_mir/src/monomorphize/collector.rs @@ -1060,8 +1060,7 @@ impl ItemLikeVisitor<'v> for RootCollector<'_, 'v> { fn visit_impl_item(&mut self, ii: &'v hir::ImplItem<'v>) { if let hir::ImplItemKind::Fn(hir::FnSig { .. }, _) = ii.kind { - let def_id = self.tcx.hir().local_def_id(ii.hir_id); - self.push_if_root(def_id); + self.push_if_root(ii.def_id); } } diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs index 0552ad7389186..368d58dc828e6 100644 --- a/compiler/rustc_passes/src/check_attr.rs +++ b/compiler/rustc_passes/src/check_attr.rs @@ -29,7 +29,7 @@ pub(crate) fn target_from_impl_item<'tcx>( match impl_item.kind { hir::ImplItemKind::Const(..) => Target::AssocConst, hir::ImplItemKind::Fn(..) => { - let parent_hir_id = tcx.hir().get_parent_item(impl_item.hir_id); + let parent_hir_id = tcx.hir().get_parent_item(impl_item.hir_id()); let containing_item = tcx.hir().expect_item(parent_hir_id); let containing_impl_is_for_trait = match &containing_item.kind { hir::ItemKind::Impl(impl_) => impl_.of_trait.is_some(), @@ -1121,7 +1121,7 @@ impl Visitor<'tcx> for CheckAttrVisitor<'tcx> { fn visit_impl_item(&mut self, impl_item: &'tcx hir::ImplItem<'tcx>) { let target = target_from_impl_item(self.tcx, impl_item); - self.check_attributes(impl_item.hir_id, &impl_item.attrs, &impl_item.span, target, None); + self.check_attributes(impl_item.hir_id(), &impl_item.attrs, &impl_item.span, target, None); intravisit::walk_impl_item(self, impl_item) } diff --git a/compiler/rustc_passes/src/dead.rs b/compiler/rustc_passes/src/dead.rs index bdf3343811635..13eed5bb349fd 100644 --- a/compiler/rustc_passes/src/dead.rs +++ b/compiler/rustc_passes/src/dead.rs @@ -420,11 +420,11 @@ impl<'v, 'k, 'tcx> ItemLikeVisitor<'v> for LifeSeeder<'k, 'tcx> { if of_trait.is_some() || has_allow_dead_code_or_lang_attr( self.tcx, - impl_item.hir_id, + impl_item.hir_id(), &impl_item.attrs, ) { - self.worklist.push(impl_item_ref.id.hir_id); + self.worklist.push(impl_item_ref.id.hir_id()); } } } @@ -664,9 +664,9 @@ impl Visitor<'tcx> for DeadVisitor<'tcx> { fn visit_impl_item(&mut self, impl_item: &'tcx hir::ImplItem<'tcx>) { match impl_item.kind { hir::ImplItemKind::Const(_, body_id) => { - if !self.symbol_is_live(impl_item.hir_id) { + if !self.symbol_is_live(impl_item.hir_id()) { self.warn_dead_code( - impl_item.hir_id, + impl_item.hir_id(), impl_item.span, impl_item.ident.name, "used", @@ -675,7 +675,7 @@ impl Visitor<'tcx> for DeadVisitor<'tcx> { self.visit_nested_body(body_id) } hir::ImplItemKind::Fn(_, body_id) => { - if !self.symbol_is_live(impl_item.hir_id) { + if !self.symbol_is_live(impl_item.hir_id()) { // FIXME(66095): Because impl_item.span is annotated with things // like expansion data, and ident.span isn't, we use the // def_span method if it's part of a macro invocation @@ -687,7 +687,7 @@ impl Visitor<'tcx> for DeadVisitor<'tcx> { } else { impl_item.ident.span }; - self.warn_dead_code(impl_item.hir_id, span, impl_item.ident.name, "used"); + self.warn_dead_code(impl_item.hir_id(), span, impl_item.ident.name, "used"); } self.visit_nested_body(body_id) } diff --git a/compiler/rustc_passes/src/diagnostic_items.rs b/compiler/rustc_passes/src/diagnostic_items.rs index ded5fa1e57b3a..2357764a0b5fc 100644 --- a/compiler/rustc_passes/src/diagnostic_items.rs +++ b/compiler/rustc_passes/src/diagnostic_items.rs @@ -35,7 +35,7 @@ impl<'v, 'tcx> ItemLikeVisitor<'v> for DiagnosticItemCollector<'tcx> { } fn visit_impl_item(&mut self, impl_item: &hir::ImplItem<'_>) { - self.observe_item(&impl_item.attrs, impl_item.hir_id); + self.observe_item(&impl_item.attrs, impl_item.hir_id()); } fn visit_foreign_item(&mut self, foreign_item: &hir::ForeignItem<'_>) { diff --git a/compiler/rustc_passes/src/hir_id_validator.rs b/compiler/rustc_passes/src/hir_id_validator.rs index 3c83fdfa11bd6..e7cdacdddda10 100644 --- a/compiler/rustc_passes/src/hir_id_validator.rs +++ b/compiler/rustc_passes/src/hir_id_validator.rs @@ -66,7 +66,7 @@ impl<'a, 'hir> ItemLikeVisitor<'hir> for OuterVisitor<'a, 'hir> { fn visit_impl_item(&mut self, i: &'hir hir::ImplItem<'hir>) { let mut inner_visitor = self.new_inner_visitor(self.hir_map); - inner_visitor.check(i.hir_id, |this| intravisit::walk_impl_item(this, i)); + inner_visitor.check(i.hir_id(), |this| intravisit::walk_impl_item(this, i)); } fn visit_foreign_item(&mut self, i: &'hir hir::ForeignItem<'hir>) { diff --git a/compiler/rustc_passes/src/hir_stats.rs b/compiler/rustc_passes/src/hir_stats.rs index 0db8481b82494..a660eb1ea2e72 100644 --- a/compiler/rustc_passes/src/hir_stats.rs +++ b/compiler/rustc_passes/src/hir_stats.rs @@ -192,7 +192,7 @@ impl<'v> hir_visit::Visitor<'v> for StatCollector<'v> { } fn visit_impl_item(&mut self, ii: &'v hir::ImplItem<'v>) { - self.record("ImplItem", Id::Node(ii.hir_id), ii); + self.record("ImplItem", Id::Node(ii.hir_id()), ii); hir_visit::walk_impl_item(self, ii) } diff --git a/compiler/rustc_passes/src/lang_items.rs b/compiler/rustc_passes/src/lang_items.rs index 84e1444b4cc4c..8e2ad7f783e9b 100644 --- a/compiler/rustc_passes/src/lang_items.rs +++ b/compiler/rustc_passes/src/lang_items.rs @@ -50,7 +50,7 @@ impl ItemLikeVisitor<'v> for LanguageItemCollector<'tcx> { fn visit_impl_item(&mut self, impl_item: &hir::ImplItem<'_>) { self.check_for_lang( target_from_impl_item(self.tcx, impl_item), - impl_item.hir_id, + impl_item.hir_id(), impl_item.attrs, ) } diff --git a/compiler/rustc_passes/src/reachable.rs b/compiler/rustc_passes/src/reachable.rs index 36d335a81df3f..20aaaea5b9809 100644 --- a/compiler/rustc_passes/src/reachable.rs +++ b/compiler/rustc_passes/src/reachable.rs @@ -43,8 +43,8 @@ fn method_might_be_inlined( impl_item: &hir::ImplItem<'_>, impl_src: LocalDefId, ) -> bool { - let codegen_fn_attrs = tcx.codegen_fn_attrs(impl_item.hir_id.owner.to_def_id()); - let generics = tcx.generics_of(tcx.hir().local_def_id(impl_item.hir_id)); + let codegen_fn_attrs = tcx.codegen_fn_attrs(impl_item.hir_id().owner.to_def_id()); + let generics = tcx.generics_of(impl_item.def_id); if codegen_fn_attrs.requests_inline() || generics.requires_monomorphization(tcx) { return true; } @@ -356,8 +356,7 @@ impl<'a, 'tcx> ItemLikeVisitor<'tcx> for CollectPrivateImplItemsVisitor<'a, 'tcx if !self.access_levels.is_reachable(item.hir_id()) { // FIXME(#53488) remove `let` let tcx = self.tcx; - self.worklist - .extend(items.iter().map(|ii_ref| tcx.hir().local_def_id(ii_ref.id.hir_id))); + self.worklist.extend(items.iter().map(|ii_ref| ii_ref.id.def_id)); let trait_def_id = match trait_ref.path.res { Res::Def(DefKind::Trait, def_id) => def_id, diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs index 7782b02985683..f18b9e4ea8f35 100644 --- a/compiler/rustc_passes/src/stability.rs +++ b/compiler/rustc_passes/src/stability.rs @@ -405,7 +405,7 @@ impl<'a, 'tcx> Visitor<'tcx> for Annotator<'a, 'tcx> { let kind = if self.in_trait_impl { AnnotationKind::Prohibited } else { AnnotationKind::Required }; self.annotate( - ii.hir_id, + ii.hir_id(), &ii.attrs, ii.span, kind, @@ -576,9 +576,9 @@ impl<'tcx> Visitor<'tcx> for MissingStabilityAnnotations<'tcx> { } fn visit_impl_item(&mut self, ii: &'tcx hir::ImplItem<'tcx>) { - let impl_def_id = self.tcx.hir().local_def_id(self.tcx.hir().get_parent_item(ii.hir_id)); + let impl_def_id = self.tcx.hir().local_def_id(self.tcx.hir().get_parent_item(ii.hir_id())); if self.tcx.impl_trait_ref(impl_def_id).is_none() { - self.check_missing_stability(ii.hir_id, ii.span); + self.check_missing_stability(ii.hir_id(), ii.span); } intravisit::walk_impl_item(self, ii); } diff --git a/compiler/rustc_privacy/src/lib.rs b/compiler/rustc_privacy/src/lib.rs index 3c0e85eb7b909..20fec4a63655a 100644 --- a/compiler/rustc_privacy/src/lib.rs +++ b/compiler/rustc_privacy/src/lib.rs @@ -663,7 +663,7 @@ impl Visitor<'tcx> for EmbargoVisitor<'tcx> { hir::ItemKind::Impl(ref impl_) => { for impl_item_ref in impl_.items { if impl_.of_trait.is_some() || impl_item_ref.vis.node.is_pub() { - self.update(impl_item_ref.id.hir_id, item_level); + self.update(impl_item_ref.id.hir_id(), item_level); } } } @@ -769,9 +769,9 @@ impl Visitor<'tcx> for EmbargoVisitor<'tcx> { self.reach(item.hir_id(), item_level).generics().predicates().ty().trait_ref(); for impl_item_ref in impl_.items { - let impl_item_level = self.get(impl_item_ref.id.hir_id); + let impl_item_level = self.get(impl_item_ref.id.hir_id()); if impl_item_level.is_some() { - self.reach(impl_item_ref.id.hir_id, impl_item_level) + self.reach(impl_item_ref.id.hir_id(), impl_item_level) .generics() .predicates() .ty(); @@ -1526,7 +1526,7 @@ impl<'a, 'tcx> Visitor<'tcx> for ObsoleteVisiblePrivateTypesVisitor<'a, 'tcx> { let impl_item = self.tcx.hir().impl_item(impl_item_ref.id); match impl_item.kind { hir::ImplItemKind::Const(..) | hir::ImplItemKind::Fn(..) => { - self.access_levels.is_reachable(impl_item_ref.id.hir_id) + self.access_levels.is_reachable(impl_item_ref.id.hir_id()) } hir::ImplItemKind::TyAlias(_) => false, } @@ -1546,8 +1546,10 @@ impl<'a, 'tcx> Visitor<'tcx> for ObsoleteVisiblePrivateTypesVisitor<'a, 'tcx> { let impl_item = self.tcx.hir().impl_item(impl_item_ref.id); match impl_item.kind { hir::ImplItemKind::Const(..) | hir::ImplItemKind::Fn(..) - if self - .item_is_public(&impl_item.hir_id, &impl_item.vis) => + if self.item_is_public( + &impl_item.hir_id(), + &impl_item.vis, + ) => { intravisit::walk_impl_item(self, impl_item) } @@ -1588,7 +1590,7 @@ impl<'a, 'tcx> Visitor<'tcx> for ObsoleteVisiblePrivateTypesVisitor<'a, 'tcx> { // methods will be visible as `Public::foo`. let mut found_pub_static = false; for impl_item_ref in impl_.items { - if self.item_is_public(&impl_item_ref.id.hir_id, &impl_item_ref.vis) { + if self.item_is_public(&impl_item_ref.id.hir_id(), &impl_item_ref.vis) { let impl_item = self.tcx.hir().impl_item(impl_item_ref.id); match impl_item_ref.kind { AssocItemKind::Const => { @@ -2002,16 +2004,12 @@ impl<'a, 'tcx> Visitor<'tcx> for PrivateItemsInPublicInterfacesVisitor<'a, 'tcx> self.check(item.hir_id(), impl_vis).generics().predicates(); for impl_item_ref in impl_.items { let impl_item_vis = if impl_.of_trait.is_none() { - min( - tcx.visibility(tcx.hir().local_def_id(impl_item_ref.id.hir_id)), - impl_vis, - tcx, - ) + min(tcx.visibility(impl_item_ref.id.def_id), impl_vis, tcx) } else { impl_vis }; self.check_assoc_item( - impl_item_ref.id.hir_id, + impl_item_ref.id.hir_id(), impl_item_ref.kind, impl_item_ref.defaultness, impl_item_vis, diff --git a/compiler/rustc_resolve/src/late/lifetimes.rs b/compiler/rustc_resolve/src/late/lifetimes.rs index 2c5e7f7c212fe..56e60d73fa851 100644 --- a/compiler/rustc_resolve/src/late/lifetimes.rs +++ b/compiler/rustc_resolve/src/late/lifetimes.rs @@ -634,7 +634,8 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> { let parent_id = self.tcx.hir().get_parent_node(hir_id); let parent_item_id = hir::ItemId { def_id: parent_id.expect_owner() }; - let parent_impl_id = hir::ImplItemId { hir_id: parent_id }; + let parent_impl_id = + hir::ImplItemId { def_id: parent_id.expect_owner() }; let parent_trait_id = hir::TraitItemId { def_id: parent_id.expect_owner() }; let krate = self.tcx.hir().krate(); @@ -803,7 +804,7 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> { self.missing_named_lifetime_spots.push((&impl_item.generics).into()); let tcx = self.tcx; self.visit_early_late( - Some(tcx.hir().get_parent_item(impl_item.hir_id)), + Some(tcx.hir().get_parent_item(impl_item.hir_id())), &sig.decl, &impl_item.generics, |this| intravisit::walk_impl_item(this, impl_item), @@ -2128,7 +2129,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { { impl_self = Some(self_ty); assoc_item_kind = - items.iter().find(|ii| ii.id.hir_id == parent).map(|ii| ii.kind); + items.iter().find(|ii| ii.id.hir_id() == parent).map(|ii| ii.kind); } Some(body) } diff --git a/compiler/rustc_save_analysis/src/dump_visitor.rs b/compiler/rustc_save_analysis/src/dump_visitor.rs index 4a58dfd429464..e9dbed20e44e1 100644 --- a/compiler/rustc_save_analysis/src/dump_visitor.rs +++ b/compiler/rustc_save_analysis/src/dump_visitor.rs @@ -1073,7 +1073,7 @@ impl<'tcx> DumpVisitor<'tcx> { hir::ImplItemKind::Const(ref ty, body) => { let body = self.tcx.hir().body(body); self.process_assoc_const( - impl_item.hir_id, + impl_item.hir_id(), impl_item.ident, &ty, Some(&body.value), @@ -1086,7 +1086,7 @@ impl<'tcx> DumpVisitor<'tcx> { self.process_method( sig, Some(body), - impl_item.hir_id, + impl_item.hir_id(), impl_item.ident, &impl_item.generics, &impl_item.vis, diff --git a/compiler/rustc_save_analysis/src/lib.rs b/compiler/rustc_save_analysis/src/lib.rs index a45406c6b046b..5801926968a64 100644 --- a/compiler/rustc_save_analysis/src/lib.rs +++ b/compiler/rustc_save_analysis/src/lib.rs @@ -358,7 +358,7 @@ impl<'tcx> SaveContext<'tcx> { parent: None, children: items .iter() - .map(|i| id_from_hir_id(i.id.hir_id, self)) + .map(|i| id_from_def_id(i.id.def_id.to_def_id())) .collect(), docs: String::new(), sig: None, diff --git a/compiler/rustc_symbol_mangling/src/test.rs b/compiler/rustc_symbol_mangling/src/test.rs index 7a667a127d3ca..b46bb39b1f715 100644 --- a/compiler/rustc_symbol_mangling/src/test.rs +++ b/compiler/rustc_symbol_mangling/src/test.rs @@ -69,7 +69,7 @@ impl hir::itemlikevisit::ItemLikeVisitor<'tcx> for SymbolNamesTest<'tcx> { } fn visit_impl_item(&mut self, impl_item: &'tcx hir::ImplItem<'tcx>) { - self.process_attrs(impl_item.hir_id); + self.process_attrs(impl_item.hir_id()); } fn visit_foreign_item(&mut self, foreign_item: &'tcx hir::ForeignItem<'tcx>) { diff --git a/compiler/rustc_ty_utils/src/ty.rs b/compiler/rustc_ty_utils/src/ty.rs index d89c8e8121861..76d27c292262d 100644 --- a/compiler/rustc_ty_utils/src/ty.rs +++ b/compiler/rustc_ty_utils/src/ty.rs @@ -105,7 +105,7 @@ fn associated_item_from_impl_item_ref( parent_def_id: LocalDefId, impl_item_ref: &hir::ImplItemRef<'_>, ) -> ty::AssocItem { - let def_id = tcx.hir().local_def_id(impl_item_ref.id.hir_id); + let def_id = impl_item_ref.id.def_id; let (kind, has_self) = match impl_item_ref.kind { hir::AssocItemKind::Const => (ty::AssocKind::Const, false), hir::AssocItemKind::Fn { has_self } => (ty::AssocKind::Fn, has_self), @@ -130,7 +130,9 @@ fn associated_item(tcx: TyCtxt<'_>, def_id: DefId) -> ty::AssocItem { let parent_item = tcx.hir().expect_item(parent_id); match parent_item.kind { hir::ItemKind::Impl(ref impl_) => { - if let Some(impl_item_ref) = impl_.items.iter().find(|i| i.id.hir_id == id) { + if let Some(impl_item_ref) = + impl_.items.iter().find(|i| i.id.def_id.to_def_id() == def_id) + { let assoc_item = associated_item_from_impl_item_ref(tcx, parent_def_id, impl_item_ref); debug_assert_eq!(assoc_item.def_id, def_id); @@ -201,11 +203,7 @@ fn associated_item_def_ids(tcx: TyCtxt<'_>, def_id: DefId) -> &[DefId] { trait_item_refs.iter().map(|trait_item_ref| trait_item_ref.id.def_id.to_def_id()), ), hir::ItemKind::Impl(ref impl_) => tcx.arena.alloc_from_iter( - impl_ - .items - .iter() - .map(|impl_item_ref| impl_item_ref.id) - .map(|id| tcx.hir().local_def_id(id.hir_id).to_def_id()), + impl_.items.iter().map(|impl_item_ref| impl_item_ref.id.def_id.to_def_id()), ), hir::ItemKind::TraitAlias(..) => &[], _ => span_bug!(item.span, "associated_item_def_ids: not impl or trait"), diff --git a/compiler/rustc_typeck/src/check/check.rs b/compiler/rustc_typeck/src/check/check.rs index 8c33abd45edc7..43da911a42f12 100644 --- a/compiler/rustc_typeck/src/check/check.rs +++ b/compiler/rustc_typeck/src/check/check.rs @@ -928,7 +928,7 @@ pub(super) fn check_impl_items_against_trait<'tcx>( // Check existing impl methods to see if they are both present in trait // and compatible with trait signature for impl_item in impl_items { - let ty_impl_item = tcx.associated_item(tcx.hir().local_def_id(impl_item.hir_id)); + let ty_impl_item = tcx.associated_item(impl_item.def_id); let mut items = associated_items.filter_by_name(tcx, ty_impl_item.ident, impl_trait_ref.def_id); diff --git a/compiler/rustc_typeck/src/check/compare_method.rs b/compiler/rustc_typeck/src/check/compare_method.rs index 5f4db8cc989fb..a30a81079335d 100644 --- a/compiler/rustc_typeck/src/check/compare_method.rs +++ b/compiler/rustc_typeck/src/check/compare_method.rs @@ -826,8 +826,8 @@ fn compare_synthetic_generics<'tcx>( let trait_m = trait_m.def_id.as_local()?; let trait_m = tcx.hir().trait_item(hir::TraitItemId { def_id: trait_m }); - let impl_m = tcx.hir().local_def_id_to_hir_id(impl_m.def_id.as_local()?); - let impl_m = tcx.hir().impl_item(hir::ImplItemId { hir_id: impl_m }); + let impl_m = impl_m.def_id.as_local()?; + let impl_m = tcx.hir().impl_item(hir::ImplItemId { def_id: impl_m }); // in case there are no generics, take the spot between the function name // and the opening paren of the argument list @@ -860,8 +860,8 @@ fn compare_synthetic_generics<'tcx>( (None, Some(hir::SyntheticTyParamKind::ImplTrait)) => { err.span_label(impl_span, "expected `impl Trait`, found generic parameter"); (|| { - let impl_m = tcx.hir().local_def_id_to_hir_id(impl_m.def_id.as_local()?); - let impl_m = tcx.hir().impl_item(hir::ImplItemId { hir_id: impl_m }); + let impl_m = impl_m.def_id.as_local()?; + let impl_m = tcx.hir().impl_item(hir::ImplItemId { def_id: impl_m }); let input_tys = match impl_m.kind { hir::ImplItemKind::Fn(ref sig, _) => sig.decl.inputs, _ => unreachable!(), diff --git a/compiler/rustc_typeck/src/check/wfcheck.rs b/compiler/rustc_typeck/src/check/wfcheck.rs index b9a96fcfb6f92..0bdcee458d75a 100644 --- a/compiler/rustc_typeck/src/check/wfcheck.rs +++ b/compiler/rustc_typeck/src/check/wfcheck.rs @@ -271,7 +271,7 @@ pub fn check_impl_item(tcx: TyCtxt<'_>, def_id: LocalDefId) { _ => None, }; - check_associated_item(tcx, impl_item.hir_id, impl_item.span, method_sig); + check_associated_item(tcx, impl_item.hir_id(), impl_item.span, method_sig); } fn check_param_wf(tcx: TyCtxt<'_>, param: &hir::GenericParam<'_>) { @@ -1360,8 +1360,7 @@ impl Visitor<'tcx> for CheckTypeWellFormedVisitor<'tcx> { fn visit_impl_item(&mut self, impl_item: &'tcx hir::ImplItem<'tcx>) { debug!("visit_impl_item: {:?}", impl_item); - let def_id = self.tcx.hir().local_def_id(impl_item.hir_id); - self.tcx.ensure().check_impl_item_well_formed(def_id); + self.tcx.ensure().check_impl_item_well_formed(impl_item.def_id); hir_visit::walk_impl_item(self, impl_item); } diff --git a/compiler/rustc_typeck/src/collect.rs b/compiler/rustc_typeck/src/collect.rs index 29c18ef4d55f5..5ad575183086d 100644 --- a/compiler/rustc_typeck/src/collect.rs +++ b/compiler/rustc_typeck/src/collect.rs @@ -286,7 +286,7 @@ impl Visitor<'tcx> for CollectItemTypesVisitor<'tcx> { } fn visit_impl_item(&mut self, impl_item: &'tcx hir::ImplItem<'tcx>) { - convert_impl_item(self.tcx, impl_item.hir_id); + convert_impl_item(self.tcx, impl_item.impl_item_id()); intravisit::walk_impl_item(self, impl_item); } } @@ -849,12 +849,12 @@ fn convert_trait_item(tcx: TyCtxt<'_>, trait_item_id: hir::TraitItemId) { tcx.ensure().predicates_of(trait_item_id.def_id); } -fn convert_impl_item(tcx: TyCtxt<'_>, impl_item_id: hir::HirId) { - let def_id = tcx.hir().local_def_id(impl_item_id); +fn convert_impl_item(tcx: TyCtxt<'_>, impl_item_id: hir::ImplItemId) { + let def_id = impl_item_id.def_id; tcx.ensure().generics_of(def_id); tcx.ensure().type_of(def_id); tcx.ensure().predicates_of(def_id); - let impl_item = tcx.hir().expect_impl_item(impl_item_id); + let impl_item = tcx.hir().impl_item(impl_item_id); match impl_item.kind { hir::ImplItemKind::Fn(..) => { tcx.ensure().fn_sig(def_id); diff --git a/compiler/rustc_typeck/src/collect/type_of.rs b/compiler/rustc_typeck/src/collect/type_of.rs index 2154280f48fce..a2aa3b308ec77 100644 --- a/compiler/rustc_typeck/src/collect/type_of.rs +++ b/compiler/rustc_typeck/src/collect/type_of.rs @@ -590,10 +590,9 @@ fn find_opaque_ty_constraints(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Ty<'_> { } fn visit_impl_item(&mut self, it: &'tcx ImplItem<'tcx>) { debug!("find_existential_constraints: visiting {:?}", it); - let def_id = self.tcx.hir().local_def_id(it.hir_id); // The opaque type itself or its children are not within its reveal scope. - if def_id.to_def_id() != self.def_id { - self.check(def_id); + if it.def_id.to_def_id() != self.def_id { + self.check(it.def_id); intravisit::walk_impl_item(self, it); } } diff --git a/compiler/rustc_typeck/src/impl_wf_check.rs b/compiler/rustc_typeck/src/impl_wf_check.rs index c3606ec564aed..d8ae0e42546a6 100644 --- a/compiler/rustc_typeck/src/impl_wf_check.rs +++ b/compiler/rustc_typeck/src/impl_wf_check.rs @@ -130,7 +130,7 @@ fn enforce_impl_params_are_constrained( // Disallow unconstrained lifetimes, but only if they appear in assoc types. let lifetimes_in_associated_types: FxHashSet<_> = impl_item_refs .iter() - .map(|item_ref| tcx.hir().local_def_id(item_ref.id.hir_id)) + .map(|item_ref| item_ref.id.def_id) .flat_map(|def_id| { let item = tcx.associated_item(def_id); match item.kind { diff --git a/compiler/rustc_typeck/src/variance/constraints.rs b/compiler/rustc_typeck/src/variance/constraints.rs index 570504aa6270b..61f3f957df84a 100644 --- a/compiler/rustc_typeck/src/variance/constraints.rs +++ b/compiler/rustc_typeck/src/variance/constraints.rs @@ -104,7 +104,7 @@ impl<'a, 'tcx, 'v> ItemLikeVisitor<'v> for ConstraintContext<'a, 'tcx> { fn visit_impl_item(&mut self, impl_item: &hir::ImplItem<'_>) { if let hir::ImplItemKind::Fn(..) = impl_item.kind { - self.visit_node_helper(impl_item.hir_id); + self.visit_node_helper(impl_item.hir_id()); } } diff --git a/compiler/rustc_typeck/src/variance/terms.rs b/compiler/rustc_typeck/src/variance/terms.rs index 9ff52c0d226d9..e60a1c4009c82 100644 --- a/compiler/rustc_typeck/src/variance/terms.rs +++ b/compiler/rustc_typeck/src/variance/terms.rs @@ -165,7 +165,7 @@ impl<'a, 'tcx, 'v> ItemLikeVisitor<'v> for TermsContext<'a, 'tcx> { fn visit_impl_item(&mut self, impl_item: &hir::ImplItem<'_>) { if let hir::ImplItemKind::Fn(..) = impl_item.kind { - self.add_inferreds_for_item(impl_item.hir_id); + self.add_inferreds_for_item(impl_item.hir_id()); } } diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index c20d3eda858d8..688470dd6918a 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -1085,7 +1085,7 @@ impl Clean for hir::TraitItem<'_> { impl Clean for hir::ImplItem<'_> { fn clean(&self, cx: &DocContext<'_>) -> Item { - let local_did = cx.tcx.hir().local_def_id(self.hir_id).to_def_id(); + let local_did = self.def_id.to_def_id(); cx.with_param_env(local_did, || { let inner = match self.kind { hir::ImplItemKind::Const(ref ty, expr) => { @@ -1116,7 +1116,7 @@ impl Clean for hir::ImplItem<'_> { let what_rustc_thinks = Item::from_def_id_and_parts(local_did, Some(self.ident.name), inner, cx); - let parent_item = cx.tcx.hir().expect_item(cx.tcx.hir().get_parent_item(self.hir_id)); + let parent_item = cx.tcx.hir().expect_item(cx.tcx.hir().get_parent_item(self.hir_id())); if let hir::ItemKind::Impl(impl_) = &parent_item.kind { if impl_.of_trait.is_some() { // Trait impl items always inherit the impl's visibility -- diff --git a/src/librustdoc/doctest.rs b/src/librustdoc/doctest.rs index 5df2a293ea24e..be02b0050e8e9 100644 --- a/src/librustdoc/doctest.rs +++ b/src/librustdoc/doctest.rs @@ -1068,9 +1068,15 @@ impl<'a, 'hir, 'tcx> intravisit::Visitor<'hir> for HirCollector<'a, 'hir, 'tcx> } fn visit_impl_item(&mut self, item: &'hir hir::ImplItem<'_>) { - self.visit_testable(item.ident.to_string(), &item.attrs, item.hir_id, item.span, |this| { - intravisit::walk_impl_item(this, item); - }); + self.visit_testable( + item.ident.to_string(), + &item.attrs, + item.hir_id(), + item.span, + |this| { + intravisit::walk_impl_item(this, item); + }, + ); } fn visit_foreign_item(&mut self, item: &'hir hir::ForeignItem<'_>) { diff --git a/src/tools/clippy/clippy_lints/src/doc.rs b/src/tools/clippy/clippy_lints/src/doc.rs index 8a82b550bdae6..67b7cf9195865 100644 --- a/src/tools/clippy/clippy_lints/src/doc.rs +++ b/src/tools/clippy/clippy_lints/src/doc.rs @@ -258,14 +258,13 @@ impl<'tcx> LateLintPass<'tcx> for DocMarkdown { } if let hir::ImplItemKind::Fn(ref sig, body_id) = item.kind { let body = cx.tcx.hir().body(body_id); - let impl_item_def_id = cx.tcx.hir().local_def_id(item.hir_id); let mut fpu = FindPanicUnwrap { cx, - typeck_results: cx.tcx.typeck(impl_item_def_id), + typeck_results: cx.tcx.typeck(item.def_id), panic_span: None, }; fpu.visit_expr(&body.value); - lint_for_missing_headers(cx, item.hir_id, item.span, sig, headers, Some(body_id), fpu.panic_span); + lint_for_missing_headers(cx, item.hir_id(), item.span, sig, headers, Some(body_id), fpu.panic_span); } } } diff --git a/src/tools/clippy/clippy_lints/src/fallible_impl_from.rs b/src/tools/clippy/clippy_lints/src/fallible_impl_from.rs index 79828efc206d6..6d522c7ef3398 100644 --- a/src/tools/clippy/clippy_lints/src/fallible_impl_from.rs +++ b/src/tools/clippy/clippy_lints/src/fallible_impl_from.rs @@ -116,10 +116,9 @@ fn lint_impl_body<'tcx>(cx: &LateContext<'tcx>, impl_span: Span, impl_items: &[h then { // check the body for `begin_panic` or `unwrap` let body = cx.tcx.hir().body(body_id); - let impl_item_def_id = cx.tcx.hir().local_def_id(impl_item.id.hir_id); let mut fpu = FindPanicUnwrap { lcx: cx, - typeck_results: cx.tcx.typeck(impl_item_def_id), + typeck_results: cx.tcx.typeck(impl_item.id.def_id), result: Vec::new(), }; fpu.visit_expr(&body.value); diff --git a/src/tools/clippy/clippy_lints/src/functions.rs b/src/tools/clippy/clippy_lints/src/functions.rs index eabc745a7b07e..0c6bf8bbdf24a 100644 --- a/src/tools/clippy/clippy_lints/src/functions.rs +++ b/src/tools/clippy/clippy_lints/src/functions.rs @@ -308,24 +308,24 @@ impl<'tcx> LateLintPass<'tcx> for Functions { fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<'_>) { if let hir::ImplItemKind::Fn(ref sig, ref body_id) = item.kind { - let is_public = cx.access_levels.is_exported(item.hir_id); + let is_public = cx.access_levels.is_exported(item.hir_id()); let fn_header_span = item.span.with_hi(sig.decl.output.span().hi()); - if is_public && trait_ref_of_method(cx, item.hir_id).is_none() { + if is_public && trait_ref_of_method(cx, item.hir_id()).is_none() { check_result_unit_err(cx, &sig.decl, item.span, fn_header_span); } let attr = must_use_attr(&item.attrs); if let Some(attr) = attr { - check_needless_must_use(cx, &sig.decl, item.hir_id, item.span, fn_header_span, attr); + check_needless_must_use(cx, &sig.decl, item.hir_id(), item.span, fn_header_span, attr); } else if is_public && !is_proc_macro(cx.sess(), &item.attrs) - && trait_ref_of_method(cx, item.hir_id).is_none() + && trait_ref_of_method(cx, item.hir_id()).is_none() { check_must_use_candidate( cx, &sig.decl, cx.tcx.hir().body(*body_id), item.span, - item.hir_id, + item.hir_id(), item.span.with_hi(sig.decl.output.span().hi()), "this method could have a `#[must_use]` attribute", ); diff --git a/src/tools/clippy/clippy_lints/src/inherent_to_string.rs b/src/tools/clippy/clippy_lints/src/inherent_to_string.rs index b723d06a6881d..76e7a4992d345 100644 --- a/src/tools/clippy/clippy_lints/src/inherent_to_string.rs +++ b/src/tools/clippy/clippy_lints/src/inherent_to_string.rs @@ -108,10 +108,10 @@ impl<'tcx> LateLintPass<'tcx> for InherentToString { if decl.inputs.len() == 1; // Check if return type is String - if is_type_diagnostic_item(cx, return_ty(cx, impl_item.hir_id), sym::string_type); + if is_type_diagnostic_item(cx, return_ty(cx, impl_item.hir_id()), sym::string_type); // Filters instances of to_string which are required by a trait - if trait_ref_of_method(cx, impl_item.hir_id).is_none(); + if trait_ref_of_method(cx, impl_item.hir_id()).is_none(); then { show_lint(cx, impl_item); @@ -124,8 +124,7 @@ fn show_lint(cx: &LateContext<'_>, item: &ImplItem<'_>) { let display_trait_id = get_trait_def_id(cx, &paths::DISPLAY_TRAIT).expect("Failed to get trait ID of `Display`!"); // Get the real type of 'self' - let fn_def_id = cx.tcx.hir().local_def_id(item.hir_id); - let self_type = cx.tcx.fn_sig(fn_def_id).input(0); + let self_type = cx.tcx.fn_sig(item.def_id).input(0); let self_type = self_type.skip_binder().peel_refs(); // Emit either a warning or an error diff --git a/src/tools/clippy/clippy_lints/src/len_zero.rs b/src/tools/clippy/clippy_lints/src/len_zero.rs index a89941ceb226b..dab3e0565cafb 100644 --- a/src/tools/clippy/clippy_lints/src/len_zero.rs +++ b/src/tools/clippy/clippy_lints/src/len_zero.rs @@ -206,17 +206,14 @@ fn check_impl_items(cx: &LateContext<'_>, item: &Item<'_>, impl_items: &[ImplIte fn is_named_self(cx: &LateContext<'_>, item: &ImplItemRef<'_>, name: &str) -> bool { item.ident.name.as_str() == name && if let AssocItemKind::Fn { has_self } = item.kind { - has_self && { - let did = cx.tcx.hir().local_def_id(item.id.hir_id); - cx.tcx.fn_sig(did).inputs().skip_binder().len() == 1 - } + has_self && cx.tcx.fn_sig(item.id.def_id).inputs().skip_binder().len() == 1 } else { false } } let is_empty = if let Some(is_empty) = impl_items.iter().find(|i| is_named_self(cx, i, "is_empty")) { - if cx.access_levels.is_exported(is_empty.id.hir_id) { + if cx.access_levels.is_exported(is_empty.id.hir_id()) { return; } "a private" @@ -225,7 +222,7 @@ fn check_impl_items(cx: &LateContext<'_>, item: &Item<'_>, impl_items: &[ImplIte }; if let Some(i) = impl_items.iter().find(|i| is_named_self(cx, i, "len")) { - if cx.access_levels.is_exported(i.id.hir_id) { + if cx.access_levels.is_exported(i.id.hir_id()) { let ty = cx.tcx.type_of(item.def_id); span_lint( diff --git a/src/tools/clippy/clippy_lints/src/lifetimes.rs b/src/tools/clippy/clippy_lints/src/lifetimes.rs index 05c747eee0760..50e6383263dd3 100644 --- a/src/tools/clippy/clippy_lints/src/lifetimes.rs +++ b/src/tools/clippy/clippy_lints/src/lifetimes.rs @@ -87,7 +87,7 @@ impl<'tcx> LateLintPass<'tcx> for Lifetimes { fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx ImplItem<'_>) { if let ImplItemKind::Fn(ref sig, id) = item.kind { - let report_extra_lifetimes = trait_ref_of_method(cx, item.hir_id).is_none(); + let report_extra_lifetimes = trait_ref_of_method(cx, item.hir_id()).is_none(); check_fn_inner( cx, &sig.decl, diff --git a/src/tools/clippy/clippy_lints/src/methods/mod.rs b/src/tools/clippy/clippy_lints/src/methods/mod.rs index a68775ffb7541..55660cc95a8e0 100644 --- a/src/tools/clippy/clippy_lints/src/methods/mod.rs +++ b/src/tools/clippy/clippy_lints/src/methods/mod.rs @@ -1685,7 +1685,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods { return; } let name = impl_item.ident.name.as_str(); - let parent = cx.tcx.hir().get_parent_item(impl_item.hir_id); + let parent = cx.tcx.hir().get_parent_item(impl_item.hir_id()); let item = cx.tcx.hir().expect_item(parent); let self_ty = cx.tcx.type_of(item.def_id); @@ -1698,8 +1698,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods { if let hir::ImplItemKind::Fn(ref sig, id) = impl_item.kind; if let Some(first_arg) = iter_input_pats(&sig.decl, cx.tcx.hir().body(id)).next(); - let method_def_id = cx.tcx.hir().local_def_id(impl_item.hir_id); - let method_sig = cx.tcx.fn_sig(method_def_id); + let method_sig = cx.tcx.fn_sig(impl_item.def_id); let method_sig = cx.tcx.erase_late_bound_regions(method_sig); let first_arg_ty = &method_sig.inputs().iter().next(); @@ -1708,7 +1707,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods { if let Some(first_arg_ty) = first_arg_ty; then { - if cx.access_levels.is_exported(impl_item.hir_id) { + if cx.access_levels.is_exported(impl_item.hir_id()) { // check missing trait implementations for method_config in &TRAIT_METHODS { if name == method_config.method_name && @@ -1750,7 +1749,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods { } if let hir::ImplItemKind::Fn(_, _) = impl_item.kind { - let ret_ty = return_ty(cx, impl_item.hir_id); + let ret_ty = return_ty(cx, impl_item.hir_id()); // walk the return type and check for Self (this does not check associated types) if contains_ty(ret_ty, self_ty) { diff --git a/src/tools/clippy/clippy_lints/src/missing_doc.rs b/src/tools/clippy/clippy_lints/src/missing_doc.rs index 5fce322933e98..761b9261772b2 100644 --- a/src/tools/clippy/clippy_lints/src/missing_doc.rs +++ b/src/tools/clippy/clippy_lints/src/missing_doc.rs @@ -171,8 +171,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc { fn check_impl_item(&mut self, cx: &LateContext<'tcx>, impl_item: &'tcx hir::ImplItem<'_>) { // If the method is an impl for a trait, don't doc. - let def_id = cx.tcx.hir().local_def_id(impl_item.hir_id); - match cx.tcx.associated_item(def_id).container { + match cx.tcx.associated_item(impl_item.def_id).container { ty::TraitContainer(_) => return, ty::ImplContainer(cid) => { if cx.tcx.impl_trait_ref(cid).is_some() { @@ -181,7 +180,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc { }, } - let (article, desc) = cx.tcx.article_and_description(def_id.to_def_id()); + let (article, desc) = cx.tcx.article_and_description(impl_item.def_id.to_def_id()); self.check_missing_docs_attrs(cx, &impl_item.attrs, impl_item.span, article, desc); } diff --git a/src/tools/clippy/clippy_lints/src/missing_inline.rs b/src/tools/clippy/clippy_lints/src/missing_inline.rs index 5132bed590a0c..47d7c5306c433 100644 --- a/src/tools/clippy/clippy_lints/src/missing_inline.rs +++ b/src/tools/clippy/clippy_lints/src/missing_inline.rs @@ -138,7 +138,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingInline { } // If the item being implemented is not exported, then we don't need #[inline] - if !cx.access_levels.is_exported(impl_item.hir_id) { + if !cx.access_levels.is_exported(impl_item.hir_id()) { return; } @@ -147,14 +147,13 @@ impl<'tcx> LateLintPass<'tcx> for MissingInline { hir::ImplItemKind::Const(..) | hir::ImplItemKind::TyAlias(_) => return, }; - let def_id = cx.tcx.hir().local_def_id(impl_item.hir_id); - let trait_def_id = match cx.tcx.associated_item(def_id).container { + let trait_def_id = match cx.tcx.associated_item(impl_item.def_id).container { TraitContainer(cid) => Some(cid), ImplContainer(cid) => cx.tcx.impl_trait_ref(cid).map(|t| t.def_id), }; if let Some(trait_def_id) = trait_def_id { - if trait_def_id.is_local() && !cx.access_levels.is_exported(impl_item.hir_id) { + if trait_def_id.is_local() && !cx.access_levels.is_exported(impl_item.hir_id()) { // If a trait is being implemented for an item, and the // trait is not exported, we don't need #[inline] return; diff --git a/src/tools/clippy/clippy_lints/src/mut_key.rs b/src/tools/clippy/clippy_lints/src/mut_key.rs index 16981946e18e7..908b7bb7ce00d 100644 --- a/src/tools/clippy/clippy_lints/src/mut_key.rs +++ b/src/tools/clippy/clippy_lints/src/mut_key.rs @@ -63,8 +63,8 @@ impl<'tcx> LateLintPass<'tcx> for MutableKeyType { fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<'tcx>) { if let hir::ImplItemKind::Fn(ref sig, ..) = item.kind { - if trait_ref_of_method(cx, item.hir_id).is_none() { - check_sig(cx, item.hir_id, &sig.decl); + if trait_ref_of_method(cx, item.hir_id()).is_none() { + check_sig(cx, item.hir_id(), &sig.decl); } } } diff --git a/src/tools/clippy/clippy_lints/src/new_without_default.rs b/src/tools/clippy/clippy_lints/src/new_without_default.rs index bd3dac663fe27..de2899c3462a4 100644 --- a/src/tools/clippy/clippy_lints/src/new_without_default.rs +++ b/src/tools/clippy/clippy_lints/src/new_without_default.rs @@ -72,7 +72,7 @@ impl<'tcx> LateLintPass<'tcx> for NewWithoutDefault { } if let hir::ImplItemKind::Fn(ref sig, _) = impl_item.kind { let name = impl_item.ident.name; - let id = impl_item.hir_id; + let id = impl_item.hir_id(); if sig.header.constness == hir::Constness::Const { // can't be implemented by default return; diff --git a/src/tools/clippy/clippy_lints/src/non_copy_const.rs b/src/tools/clippy/clippy_lints/src/non_copy_const.rs index 0b2262d849076..8aebce67917af 100644 --- a/src/tools/clippy/clippy_lints/src/non_copy_const.rs +++ b/src/tools/clippy/clippy_lints/src/non_copy_const.rs @@ -271,7 +271,7 @@ impl<'tcx> LateLintPass<'tcx> for NonCopyConst { fn check_impl_item(&mut self, cx: &LateContext<'tcx>, impl_item: &'tcx ImplItem<'_>) { if let ImplItemKind::Const(hir_ty, body_id) = &impl_item.kind { - let item_hir_id = cx.tcx.hir().get_parent_node(impl_item.hir_id); + let item_hir_id = cx.tcx.hir().get_parent_node(impl_item.hir_id()); let item = cx.tcx.hir().expect_item(item_hir_id); match &item.kind { diff --git a/src/tools/clippy/clippy_lints/src/partialeq_ne_impl.rs b/src/tools/clippy/clippy_lints/src/partialeq_ne_impl.rs index ed314937ce8be..3d6129aa78d4c 100644 --- a/src/tools/clippy/clippy_lints/src/partialeq_ne_impl.rs +++ b/src/tools/clippy/clippy_lints/src/partialeq_ne_impl.rs @@ -44,7 +44,7 @@ impl<'tcx> LateLintPass<'tcx> for PartialEqNeImpl { span_lint_hir( cx, PARTIALEQ_NE_IMPL, - impl_item.id.hir_id, + impl_item.id.hir_id(), impl_item.span, "re-implementing `PartialEq::ne` is unnecessary", ); diff --git a/src/tools/clippy/clippy_lints/src/ptr.rs b/src/tools/clippy/clippy_lints/src/ptr.rs index ee4ad086eb9a2..de2fb8decb715 100644 --- a/src/tools/clippy/clippy_lints/src/ptr.rs +++ b/src/tools/clippy/clippy_lints/src/ptr.rs @@ -130,13 +130,13 @@ impl<'tcx> LateLintPass<'tcx> for Ptr { fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx ImplItem<'_>) { if let ImplItemKind::Fn(ref sig, body_id) = item.kind { - let parent_item = cx.tcx.hir().get_parent_item(item.hir_id); + let parent_item = cx.tcx.hir().get_parent_item(item.hir_id()); if let Some(Node::Item(it)) = cx.tcx.hir().find(parent_item) { if let ItemKind::Impl(Impl { of_trait: Some(_), .. }) = it.kind { return; // ignore trait impls } } - check_fn(cx, &sig.decl, item.hir_id, Some(body_id)); + check_fn(cx, &sig.decl, item.hir_id(), Some(body_id)); } } diff --git a/src/tools/clippy/clippy_lints/src/unused_self.rs b/src/tools/clippy/clippy_lints/src/unused_self.rs index 5349c4f7eb8a7..73c64b8084058 100644 --- a/src/tools/clippy/clippy_lints/src/unused_self.rs +++ b/src/tools/clippy/clippy_lints/src/unused_self.rs @@ -44,10 +44,9 @@ impl<'tcx> LateLintPass<'tcx> for UnusedSelf { if impl_item.span.from_expansion() { return; } - let parent = cx.tcx.hir().get_parent_item(impl_item.hir_id); + let parent = cx.tcx.hir().get_parent_item(impl_item.hir_id()); let parent_item = cx.tcx.hir().expect_item(parent); - let def_id = cx.tcx.hir().local_def_id(impl_item.hir_id); - let assoc_item = cx.tcx.associated_item(def_id); + let assoc_item = cx.tcx.associated_item(impl_item.def_id); if_chain! { if let ItemKind::Impl(Impl { of_trait: None, .. }) = parent_item.kind; if assoc_item.fn_has_self_parameter; diff --git a/src/tools/clippy/clippy_lints/src/unwrap_in_result.rs b/src/tools/clippy/clippy_lints/src/unwrap_in_result.rs index fde3102933098..8cb7429849da6 100644 --- a/src/tools/clippy/clippy_lints/src/unwrap_in_result.rs +++ b/src/tools/clippy/clippy_lints/src/unwrap_in_result.rs @@ -57,8 +57,8 @@ impl<'tcx> LateLintPass<'tcx> for UnwrapInResult { // first check if it's a method or function if let hir::ImplItemKind::Fn(ref _signature, _) = impl_item.kind; // checking if its return type is `result` or `option` - if is_type_diagnostic_item(cx, return_ty(cx, impl_item.hir_id), sym::result_type) - || is_type_diagnostic_item(cx, return_ty(cx, impl_item.hir_id), sym::option_type); + if is_type_diagnostic_item(cx, return_ty(cx, impl_item.hir_id()), sym::result_type) + || is_type_diagnostic_item(cx, return_ty(cx, impl_item.hir_id()), sym::option_type); then { lint_impl_body(cx, impl_item.span, impl_item); } @@ -114,10 +114,9 @@ fn lint_impl_body<'tcx>(cx: &LateContext<'tcx>, impl_span: Span, impl_item: &'tc if let ImplItemKind::Fn(_, body_id) = impl_item.kind; then { let body = cx.tcx.hir().body(body_id); - let impl_item_def_id = cx.tcx.hir().local_def_id(impl_item.hir_id); let mut fpu = FindExpectUnwrap { lcx: cx, - typeck_results: cx.tcx.typeck(impl_item_def_id), + typeck_results: cx.tcx.typeck(impl_item.def_id), result: Vec::new(), }; fpu.visit_expr(&body.value); From 996dc8d5c55a496bfbdc99a936fb6055bcbe2fcd Mon Sep 17 00:00:00 2001 From: Camille GILLOT Date: Mon, 1 Feb 2021 00:33:38 +0100 Subject: [PATCH 08/14] Only store a LocalDefId in hir::ForeignItem. --- compiler/rustc_ast_lowering/src/item.rs | 6 ++-- compiler/rustc_hir/src/hir.rs | 33 ++++++++++++++----- compiler/rustc_hir/src/intravisit.rs | 2 +- compiler/rustc_hir/src/stable_hash_impls.rs | 26 +++++++++++---- .../src/persist/dirty_clean.rs | 2 +- compiler/rustc_lint/src/builtin.rs | 25 ++++++-------- compiler/rustc_lint/src/late.rs | 4 +-- compiler/rustc_lint/src/levels.rs | 2 +- compiler/rustc_lint/src/types.rs | 6 ++-- .../rustc_metadata/src/foreign_modules.rs | 10 +++--- compiler/rustc_metadata/src/rmeta/encoder.rs | 6 ++-- .../rustc_middle/src/hir/map/collector.rs | 10 ++---- compiler/rustc_middle/src/hir/map/mod.rs | 2 +- compiler/rustc_passes/src/check_attr.rs | 2 +- compiler/rustc_passes/src/dead.rs | 14 +++++--- compiler/rustc_passes/src/diagnostic_items.rs | 2 +- compiler/rustc_passes/src/hir_id_validator.rs | 2 +- compiler/rustc_passes/src/hir_stats.rs | 2 +- compiler/rustc_passes/src/stability.rs | 4 +-- compiler/rustc_privacy/src/lib.rs | 12 +++---- .../rustc_save_analysis/src/dump_visitor.rs | 4 +-- compiler/rustc_save_analysis/src/lib.rs | 4 +-- compiler/rustc_save_analysis/src/sig.rs | 8 ++--- compiler/rustc_symbol_mangling/src/test.rs | 2 +- compiler/rustc_typeck/src/check/check.rs | 2 +- compiler/rustc_typeck/src/check/intrinsic.rs | 16 ++++----- compiler/rustc_typeck/src/check/wfcheck.rs | 4 +-- compiler/rustc_typeck/src/collect.rs | 9 +++-- .../rustc_typeck/src/variance/constraints.rs | 2 +- compiler/rustc_typeck/src/variance/terms.rs | 2 +- src/librustdoc/clean/mod.rs | 6 ++-- src/librustdoc/doctest.rs | 12 +++++-- 32 files changed, 133 insertions(+), 110 deletions(-) diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs index b80b4a6b9b24b..f88c73aee53c8 100644 --- a/compiler/rustc_ast_lowering/src/item.rs +++ b/compiler/rustc_ast_lowering/src/item.rs @@ -111,7 +111,7 @@ impl<'a> Visitor<'a> for ItemLowerer<'a, '_, '_> { self.lctx.allocate_hir_id_counter(item.id); self.lctx.with_hir_id_owner(item.id, |lctx| { let hir_item = lctx.lower_foreign_item(item); - let id = hir::ForeignItemId { hir_id: hir_item.hir_id }; + let id = hir_item.foreign_item_id(); lctx.foreign_items.insert(id, hir_item); lctx.modules.get_mut(&lctx.current_module).unwrap().foreign_items.insert(id); }); @@ -711,7 +711,7 @@ impl<'hir> LoweringContext<'_, 'hir> { fn lower_foreign_item(&mut self, i: &ForeignItem) -> hir::ForeignItem<'hir> { let def_id = self.resolver.local_def_id(i.id); hir::ForeignItem { - hir_id: self.lower_node_id(i.id), + def_id, ident: i.ident, attrs: self.lower_attrs(&i.attrs), kind: match i.kind { @@ -746,7 +746,7 @@ impl<'hir> LoweringContext<'_, 'hir> { fn lower_foreign_item_ref(&mut self, i: &ForeignItem) -> hir::ForeignItemRef<'hir> { hir::ForeignItemRef { - id: hir::ForeignItemId { hir_id: self.lower_node_id(i.id) }, + id: hir::ForeignItemId { def_id: self.lower_node_id(i.id).expect_owner() }, ident: i.ident, span: i.span, vis: self.lower_visibility(&i.vis, Some(i.id)), diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs index ea23013fa0abd..a0950958455af 100644 --- a/compiler/rustc_hir/src/hir.rs +++ b/compiler/rustc_hir/src/hir.rs @@ -2783,7 +2783,14 @@ pub enum AssocItemKind { // so it can fetched later. #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Encodable, Debug)] pub struct ForeignItemId { - pub hir_id: HirId, + pub def_id: LocalDefId, +} + +impl ForeignItemId { + pub fn hir_id(&self) -> HirId { + // Items are always HIR owners. + HirId::make_owner(self.def_id) + } } /// A reference from a foreign block to one of its items. This @@ -2801,17 +2808,27 @@ pub struct ForeignItemRef<'hir> { pub vis: Visibility<'hir>, } -#[derive(Debug, HashStable_Generic)] +#[derive(Debug)] pub struct ForeignItem<'hir> { - #[stable_hasher(project(name))] pub ident: Ident, pub attrs: &'hir [Attribute], pub kind: ForeignItemKind<'hir>, - pub hir_id: HirId, + pub def_id: LocalDefId, pub span: Span, pub vis: Visibility<'hir>, } +impl ForeignItem<'_> { + pub fn hir_id(&self) -> HirId { + // Items are always HIR owners. + HirId::make_owner(self.def_id) + } + + pub fn foreign_item_id(&self) -> ForeignItemId { + ForeignItemId { def_id: self.def_id } + } +} + /// An item within an `extern` block. #[derive(Debug, HashStable_Generic)] pub enum ForeignItemKind<'hir> { @@ -2923,9 +2940,9 @@ impl<'hir> Node<'hir> { match self { Node::Item(Item { def_id, .. }) | Node::TraitItem(TraitItem { def_id, .. }) - | Node::ImplItem(ImplItem { def_id, .. }) => Some(HirId::make_owner(*def_id)), - Node::ForeignItem(ForeignItem { hir_id, .. }) - | Node::Field(StructField { hir_id, .. }) + | Node::ImplItem(ImplItem { def_id, .. }) + | Node::ForeignItem(ForeignItem { def_id, .. }) => Some(HirId::make_owner(*def_id)), + Node::Field(StructField { hir_id, .. }) | Node::AnonConst(AnonConst { hir_id, .. }) | Node::Expr(Expr { hir_id, .. }) | Node::Stmt(Stmt { hir_id, .. }) @@ -2960,5 +2977,5 @@ mod size_asserts { rustc_data_structures::static_assert_size!(super::Item<'static>, 200); rustc_data_structures::static_assert_size!(super::TraitItem<'static>, 144); rustc_data_structures::static_assert_size!(super::ImplItem<'static>, 168); - rustc_data_structures::static_assert_size!(super::ForeignItem<'static>, 160); + rustc_data_structures::static_assert_size!(super::ForeignItem<'static>, 152); } diff --git a/compiler/rustc_hir/src/intravisit.rs b/compiler/rustc_hir/src/intravisit.rs index 960a06e043865..c59464a0cb6fc 100644 --- a/compiler/rustc_hir/src/intravisit.rs +++ b/compiler/rustc_hir/src/intravisit.rs @@ -836,7 +836,7 @@ pub fn walk_pat<'v, V: Visitor<'v>>(visitor: &mut V, pattern: &'v Pat<'v>) { } pub fn walk_foreign_item<'v, V: Visitor<'v>>(visitor: &mut V, foreign_item: &'v ForeignItem<'v>) { - visitor.visit_id(foreign_item.hir_id); + visitor.visit_id(foreign_item.hir_id()); visitor.visit_vis(&foreign_item.vis); visitor.visit_ident(foreign_item.ident); diff --git a/compiler/rustc_hir/src/stable_hash_impls.rs b/compiler/rustc_hir/src/stable_hash_impls.rs index a344af1237f27..091e1ed9971c2 100644 --- a/compiler/rustc_hir/src/stable_hash_impls.rs +++ b/compiler/rustc_hir/src/stable_hash_impls.rs @@ -1,8 +1,8 @@ use rustc_data_structures::stable_hasher::{HashStable, StableHasher, ToStableHashKey}; use crate::hir::{ - BodyId, Expr, ForeignItemId, ImplItem, ImplItemId, Item, ItemId, Mod, TraitItem, TraitItemId, - Ty, VisibilityKind, + BodyId, Expr, ForeignItem, ForeignItemId, ImplItem, ImplItemId, Item, ItemId, Mod, TraitItem, + TraitItemId, Ty, VisibilityKind, }; use crate::hir_id::{HirId, ItemLocalId}; use rustc_span::def_id::{DefPathHash, LocalDefId}; @@ -62,11 +62,11 @@ impl ToStableHashKey for ImplItemId { } impl ToStableHashKey for ForeignItemId { - type KeyType = (DefPathHash, ItemLocalId); + type KeyType = DefPathHash; #[inline] - fn to_stable_hash_key(&self, hcx: &HirCtx) -> (DefPathHash, ItemLocalId) { - self.hir_id.to_stable_hash_key(hcx) + fn to_stable_hash_key(&self, hcx: &HirCtx) -> DefPathHash { + hcx.local_def_path_hash(self.def_id) } } @@ -97,7 +97,7 @@ impl HashStable for ItemId { impl HashStable for ForeignItemId { fn hash_stable(&self, hcx: &mut HirCtx, hasher: &mut StableHasher) { - hcx.hash_reference_to_item(self.hir_id, hasher) + hcx.hash_reference_to_item(self.hir_id(), hasher) } } @@ -176,6 +176,20 @@ impl HashStable for ImplItem<'_> { } } +impl HashStable for ForeignItem<'_> { + fn hash_stable(&self, hcx: &mut HirCtx, hasher: &mut StableHasher) { + let ForeignItem { def_id: _, ident, ref attrs, ref kind, span, ref vis } = *self; + + hcx.hash_hir_item_like(|hcx| { + ident.name.hash_stable(hcx, hasher); + attrs.hash_stable(hcx, hasher); + kind.hash_stable(hcx, hasher); + span.hash_stable(hcx, hasher); + vis.hash_stable(hcx, hasher); + }); + } +} + impl HashStable for Item<'_> { fn hash_stable(&self, hcx: &mut HirCtx, hasher: &mut StableHasher) { let Item { ident, ref attrs, def_id: _, ref kind, ref vis, span } = *self; diff --git a/compiler/rustc_incremental/src/persist/dirty_clean.rs b/compiler/rustc_incremental/src/persist/dirty_clean.rs index cbe1e29d6d418..752431247f064 100644 --- a/compiler/rustc_incremental/src/persist/dirty_clean.rs +++ b/compiler/rustc_incremental/src/persist/dirty_clean.rs @@ -462,7 +462,7 @@ impl ItemLikeVisitor<'tcx> for DirtyCleanVisitor<'tcx> { } fn visit_foreign_item(&mut self, item: &hir::ForeignItem<'_>) { - self.check_item(item.hir_id, item.span); + self.check_item(item.hir_id(), item.span); } } diff --git a/compiler/rustc_lint/src/builtin.rs b/compiler/rustc_lint/src/builtin.rs index 6ab7089248946..71017fcde876f 100644 --- a/compiler/rustc_lint/src/builtin.rs +++ b/compiler/rustc_lint/src/builtin.rs @@ -660,11 +660,10 @@ impl<'tcx> LateLintPass<'tcx> for MissingDoc { } fn check_foreign_item(&mut self, cx: &LateContext<'_>, foreign_item: &hir::ForeignItem<'_>) { - let def_id = cx.tcx.hir().local_def_id(foreign_item.hir_id); - let (article, desc) = cx.tcx.article_and_description(def_id.to_def_id()); + let (article, desc) = cx.tcx.article_and_description(foreign_item.def_id.to_def_id()); self.check_missing_docs_attrs( cx, - Some(foreign_item.hir_id), + Some(foreign_item.hir_id()), &foreign_item.attrs, foreign_item.span, article, @@ -1365,7 +1364,7 @@ impl<'tcx> LateLintPass<'tcx> for UnreachablePub { self.perform_lint( cx, "item", - foreign_item.hir_id, + foreign_item.hir_id(), &foreign_item.vis, foreign_item.span, true, @@ -2675,10 +2674,7 @@ impl ClashingExternDeclarations { /// Insert a new foreign item into the seen set. If a symbol with the same name already exists /// for the item, return its HirId without updating the set. fn insert(&mut self, tcx: TyCtxt<'_>, fi: &hir::ForeignItem<'_>) -> Option { - let hid = fi.hir_id; - - let local_did = tcx.hir().local_def_id(fi.hir_id); - let did = local_did.to_def_id(); + let did = fi.def_id.to_def_id(); let instance = Instance::new(did, ty::List::identity_for_item(tcx, did)); let name = Symbol::intern(tcx.symbol_name(instance).name); if let Some(&hir_id) = self.seen_decls.get(&name) { @@ -2687,7 +2683,7 @@ impl ClashingExternDeclarations { // This lets us avoid emitting "knock-on" diagnostics. Some(hir_id) } else { - self.seen_decls.insert(name, hid) + self.seen_decls.insert(name, fi.hir_id()) } } @@ -2695,16 +2691,15 @@ impl ClashingExternDeclarations { /// the name specified in a #[link_name = ...] attribute if one was specified, else, just the /// symbol's name. fn name_of_extern_decl(tcx: TyCtxt<'_>, fi: &hir::ForeignItem<'_>) -> SymbolName { - let did = tcx.hir().local_def_id(fi.hir_id); if let Some((overridden_link_name, overridden_link_name_span)) = - tcx.codegen_fn_attrs(did).link_name.map(|overridden_link_name| { + tcx.codegen_fn_attrs(fi.def_id).link_name.map(|overridden_link_name| { // FIXME: Instead of searching through the attributes again to get span // information, we could have codegen_fn_attrs also give span information back for // where the attribute was defined. However, until this is found to be a // bottleneck, this does just fine. ( overridden_link_name, - tcx.get_attrs(did.to_def_id()) + tcx.get_attrs(fi.def_id.to_def_id()) .iter() .find(|at| tcx.sess.check_name(at, sym::link_name)) .unwrap() @@ -2932,10 +2927,10 @@ impl<'tcx> LateLintPass<'tcx> for ClashingExternDeclarations { let tcx = cx.tcx; if let Some(existing_hid) = self.insert(tcx, this_fi) { let existing_decl_ty = tcx.type_of(tcx.hir().local_def_id(existing_hid)); - let this_decl_ty = tcx.type_of(tcx.hir().local_def_id(this_fi.hir_id)); + let this_decl_ty = tcx.type_of(this_fi.def_id); debug!( "ClashingExternDeclarations: Comparing existing {:?}: {:?} to this {:?}: {:?}", - existing_hid, existing_decl_ty, this_fi.hir_id, this_decl_ty + existing_hid, existing_decl_ty, this_fi.def_id, this_decl_ty ); // Check that the declarations match. if !Self::structurally_same_type( @@ -2957,7 +2952,7 @@ impl<'tcx> LateLintPass<'tcx> for ClashingExternDeclarations { // Finally, emit the diagnostic. tcx.struct_span_lint_hir( CLASHING_EXTERN_DECLARATIONS, - this_fi.hir_id, + this_fi.hir_id(), get_relevant_span(this_fi), |lint| { let mut expected_str = DiagnosticStyledString::new(); diff --git a/compiler/rustc_lint/src/late.rs b/compiler/rustc_lint/src/late.rs index 0c4dbd9c47f8c..c76f8eea201c8 100644 --- a/compiler/rustc_lint/src/late.rs +++ b/compiler/rustc_lint/src/late.rs @@ -155,8 +155,8 @@ impl<'tcx, T: LateLintPass<'tcx>> hir_visit::Visitor<'tcx> for LateContextAndPas } fn visit_foreign_item(&mut self, it: &'tcx hir::ForeignItem<'tcx>) { - self.with_lint_attrs(it.hir_id, &it.attrs, |cx| { - cx.with_param_env(it.hir_id, |cx| { + self.with_lint_attrs(it.hir_id(), &it.attrs, |cx| { + cx.with_param_env(it.hir_id(), |cx| { lint_callback!(cx, check_foreign_item, it); hir_visit::walk_foreign_item(cx, it); lint_callback!(cx, check_foreign_item_post, it); diff --git a/compiler/rustc_lint/src/levels.rs b/compiler/rustc_lint/src/levels.rs index 0b34186bfc1b6..a06e9e5dce681 100644 --- a/compiler/rustc_lint/src/levels.rs +++ b/compiler/rustc_lint/src/levels.rs @@ -583,7 +583,7 @@ impl<'tcx> intravisit::Visitor<'tcx> for LintLevelMapBuilder<'_, 'tcx> { } fn visit_foreign_item(&mut self, it: &'tcx hir::ForeignItem<'tcx>) { - self.with_lint_attrs(it.hir_id, &it.attrs, |builder| { + self.with_lint_attrs(it.hir_id(), &it.attrs, |builder| { intravisit::walk_foreign_item(builder, it); }) } diff --git a/compiler/rustc_lint/src/types.rs b/compiler/rustc_lint/src/types.rs index 55ed0a7156c24..4d70e33c607df 100644 --- a/compiler/rustc_lint/src/types.rs +++ b/compiler/rustc_lint/src/types.rs @@ -1262,15 +1262,15 @@ impl<'a, 'tcx> ImproperCTypesVisitor<'a, 'tcx> { impl<'tcx> LateLintPass<'tcx> for ImproperCTypesDeclarations { fn check_foreign_item(&mut self, cx: &LateContext<'_>, it: &hir::ForeignItem<'_>) { let mut vis = ImproperCTypesVisitor { cx, mode: CItemKind::Declaration }; - let abi = cx.tcx.hir().get_foreign_abi(it.hir_id); + let abi = cx.tcx.hir().get_foreign_abi(it.hir_id()); if !vis.is_internal_abi(abi) { match it.kind { hir::ForeignItemKind::Fn(ref decl, _, _) => { - vis.check_foreign_fn(it.hir_id, decl); + vis.check_foreign_fn(it.hir_id(), decl); } hir::ForeignItemKind::Static(ref ty, _) => { - vis.check_foreign_static(it.hir_id, ty.span); + vis.check_foreign_static(it.hir_id(), ty.span); } hir::ForeignItemKind::Type => (), } diff --git a/compiler/rustc_metadata/src/foreign_modules.rs b/compiler/rustc_metadata/src/foreign_modules.rs index f1ab8e1961adb..3d3071c18f249 100644 --- a/compiler/rustc_metadata/src/foreign_modules.rs +++ b/compiler/rustc_metadata/src/foreign_modules.rs @@ -4,25 +4,23 @@ use rustc_middle::middle::cstore::ForeignModule; use rustc_middle::ty::TyCtxt; crate fn collect(tcx: TyCtxt<'_>) -> Vec { - let mut collector = Collector { tcx, modules: Vec::new() }; + let mut collector = Collector { modules: Vec::new() }; tcx.hir().krate().visit_all_item_likes(&mut collector); collector.modules } -struct Collector<'tcx> { - tcx: TyCtxt<'tcx>, +struct Collector { modules: Vec, } -impl ItemLikeVisitor<'tcx> for Collector<'tcx> { +impl ItemLikeVisitor<'tcx> for Collector { fn visit_item(&mut self, it: &'tcx hir::Item<'tcx>) { let items = match it.kind { hir::ItemKind::ForeignMod { items, .. } => items, _ => return, }; - let foreign_items = - items.iter().map(|it| self.tcx.hir().local_def_id(it.id.hir_id).to_def_id()).collect(); + let foreign_items = items.iter().map(|it| it.id.def_id.to_def_id()).collect(); self.modules.push(ForeignModule { foreign_items, def_id: it.def_id.to_def_id() }); } diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs index 33e6696970e52..905b0b37cf788 100644 --- a/compiler/rustc_metadata/src/rmeta/encoder.rs +++ b/compiler/rustc_metadata/src/rmeta/encoder.rs @@ -1411,8 +1411,7 @@ impl EncodeContext<'a, 'tcx> { hir::ItemKind::ForeignMod { items, .. } => record!(self.tables.children[def_id] <- items .iter() - .map(|foreign_item| tcx.hir().local_def_id( - foreign_item.id.hir_id).local_def_index) + .map(|foreign_item| foreign_item.id.def_id.local_def_index) ), hir::ItemKind::Enum(..) => record!(self.tables.children[def_id] <- self.tcx.adt_def(def_id).variants.iter().map(|v| { @@ -1859,8 +1858,7 @@ impl Visitor<'tcx> for EncodeContext<'a, 'tcx> { } fn visit_foreign_item(&mut self, ni: &'tcx hir::ForeignItem<'tcx>) { intravisit::walk_foreign_item(self, ni); - let def_id = self.tcx.hir().local_def_id(ni.hir_id); - self.encode_info_for_foreign_item(def_id.to_def_id(), ni); + self.encode_info_for_foreign_item(ni.def_id.to_def_id(), ni); } fn visit_generics(&mut self, generics: &'tcx hir::Generics<'tcx>) { intravisit::walk_generics(self, generics); diff --git a/compiler/rustc_middle/src/hir/map/collector.rs b/compiler/rustc_middle/src/hir/map/collector.rs index 5365f474ec3ee..11d8202633521 100644 --- a/compiler/rustc_middle/src/hir/map/collector.rs +++ b/compiler/rustc_middle/src/hir/map/collector.rs @@ -354,14 +354,10 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> { } fn visit_foreign_item(&mut self, fi: &'hir ForeignItem<'hir>) { - debug_assert_eq!( - fi.hir_id.owner, - self.definitions.opt_hir_id_to_local_def_id(fi.hir_id).unwrap() - ); - self.with_dep_node_owner(fi.hir_id.owner, fi, |this, hash| { - this.insert_with_hash(fi.span, fi.hir_id, Node::ForeignItem(fi), hash); + self.with_dep_node_owner(fi.def_id, fi, |this, hash| { + this.insert_with_hash(fi.span, fi.hir_id(), Node::ForeignItem(fi), hash); - this.with_parent(fi.hir_id, |this| { + this.with_parent(fi.hir_id(), |this| { intravisit::walk_foreign_item(this, fi); }); }); diff --git a/compiler/rustc_middle/src/hir/map/mod.rs b/compiler/rustc_middle/src/hir/map/mod.rs index 4ded4171b5efc..c4f469ca7f441 100644 --- a/compiler/rustc_middle/src/hir/map/mod.rs +++ b/compiler/rustc_middle/src/hir/map/mod.rs @@ -322,7 +322,7 @@ impl<'hir> Map<'hir> { } pub fn foreign_item(&self, id: ForeignItemId) -> &'hir ForeignItem<'hir> { - match self.find(id.hir_id).unwrap() { + match self.find(id.hir_id()).unwrap() { Node::ForeignItem(item) => item, _ => bug!(), } diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs index 368d58dc828e6..f5ab4273e713e 100644 --- a/compiler/rustc_passes/src/check_attr.rs +++ b/compiler/rustc_passes/src/check_attr.rs @@ -1110,7 +1110,7 @@ impl Visitor<'tcx> for CheckAttrVisitor<'tcx> { fn visit_foreign_item(&mut self, f_item: &'tcx ForeignItem<'tcx>) { let target = Target::from_foreign_item(f_item); self.check_attributes( - f_item.hir_id, + f_item.hir_id(), &f_item.attrs, &f_item.span, target, diff --git a/compiler/rustc_passes/src/dead.rs b/compiler/rustc_passes/src/dead.rs index 13eed5bb349fd..d51b501f7ae3d 100644 --- a/compiler/rustc_passes/src/dead.rs +++ b/compiler/rustc_passes/src/dead.rs @@ -453,9 +453,13 @@ impl<'v, 'k, 'tcx> ItemLikeVisitor<'v> for LifeSeeder<'k, 'tcx> { fn visit_foreign_item(&mut self, foreign_item: &hir::ForeignItem<'_>) { use hir::ForeignItemKind::{Fn, Static}; if matches!(foreign_item.kind, Static(..) | Fn(..)) - && has_allow_dead_code_or_lang_attr(self.tcx, foreign_item.hir_id, &foreign_item.attrs) + && has_allow_dead_code_or_lang_attr( + self.tcx, + foreign_item.hir_id(), + &foreign_item.attrs, + ) { - self.worklist.push(foreign_item.hir_id); + self.worklist.push(foreign_item.hir_id()); } } } @@ -542,8 +546,8 @@ impl DeadVisitor<'tcx> { } fn should_warn_about_foreign_item(&mut self, fi: &hir::ForeignItem<'_>) -> bool { - !self.symbol_is_live(fi.hir_id) - && !has_allow_dead_code_or_lang_attr(self.tcx, fi.hir_id, &fi.attrs) + !self.symbol_is_live(fi.hir_id()) + && !has_allow_dead_code_or_lang_attr(self.tcx, fi.hir_id(), &fi.attrs) } // id := HIR id of an item's definition. @@ -649,7 +653,7 @@ impl Visitor<'tcx> for DeadVisitor<'tcx> { fn visit_foreign_item(&mut self, fi: &'tcx hir::ForeignItem<'tcx>) { if self.should_warn_about_foreign_item(fi) { - self.warn_dead_code(fi.hir_id, fi.span, fi.ident.name, "used"); + self.warn_dead_code(fi.hir_id(), fi.span, fi.ident.name, "used"); } intravisit::walk_foreign_item(self, fi); } diff --git a/compiler/rustc_passes/src/diagnostic_items.rs b/compiler/rustc_passes/src/diagnostic_items.rs index 2357764a0b5fc..496973947ca90 100644 --- a/compiler/rustc_passes/src/diagnostic_items.rs +++ b/compiler/rustc_passes/src/diagnostic_items.rs @@ -39,7 +39,7 @@ impl<'v, 'tcx> ItemLikeVisitor<'v> for DiagnosticItemCollector<'tcx> { } fn visit_foreign_item(&mut self, foreign_item: &hir::ForeignItem<'_>) { - self.observe_item(foreign_item.attrs, foreign_item.hir_id); + self.observe_item(foreign_item.attrs, foreign_item.hir_id()); } } diff --git a/compiler/rustc_passes/src/hir_id_validator.rs b/compiler/rustc_passes/src/hir_id_validator.rs index e7cdacdddda10..0f1ff71cc2f29 100644 --- a/compiler/rustc_passes/src/hir_id_validator.rs +++ b/compiler/rustc_passes/src/hir_id_validator.rs @@ -71,7 +71,7 @@ impl<'a, 'hir> ItemLikeVisitor<'hir> for OuterVisitor<'a, 'hir> { fn visit_foreign_item(&mut self, i: &'hir hir::ForeignItem<'hir>) { let mut inner_visitor = self.new_inner_visitor(self.hir_map); - inner_visitor.check(i.hir_id, |this| intravisit::walk_foreign_item(this, i)); + inner_visitor.check(i.hir_id(), |this| intravisit::walk_foreign_item(this, i)); } } diff --git a/compiler/rustc_passes/src/hir_stats.rs b/compiler/rustc_passes/src/hir_stats.rs index a660eb1ea2e72..9e1a3c61628a4 100644 --- a/compiler/rustc_passes/src/hir_stats.rs +++ b/compiler/rustc_passes/src/hir_stats.rs @@ -130,7 +130,7 @@ impl<'v> hir_visit::Visitor<'v> for StatCollector<'v> { } fn visit_foreign_item(&mut self, i: &'v hir::ForeignItem<'v>) { - self.record("ForeignItem", Id::Node(i.hir_id), i); + self.record("ForeignItem", Id::Node(i.hir_id()), i); hir_visit::walk_foreign_item(self, i) } diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs index f18b9e4ea8f35..0569e7fa3ab92 100644 --- a/compiler/rustc_passes/src/stability.rs +++ b/compiler/rustc_passes/src/stability.rs @@ -459,7 +459,7 @@ impl<'a, 'tcx> Visitor<'tcx> for Annotator<'a, 'tcx> { fn visit_foreign_item(&mut self, i: &'tcx hir::ForeignItem<'tcx>) { self.annotate( - i.hir_id, + i.hir_id(), &i.attrs, i.span, AnnotationKind::Required, @@ -594,7 +594,7 @@ impl<'tcx> Visitor<'tcx> for MissingStabilityAnnotations<'tcx> { } fn visit_foreign_item(&mut self, i: &'tcx hir::ForeignItem<'tcx>) { - self.check_missing_stability(i.hir_id, i.span); + self.check_missing_stability(i.hir_id(), i.span); intravisit::walk_foreign_item(self, i); } diff --git a/compiler/rustc_privacy/src/lib.rs b/compiler/rustc_privacy/src/lib.rs index 20fec4a63655a..a7327fb012f33 100644 --- a/compiler/rustc_privacy/src/lib.rs +++ b/compiler/rustc_privacy/src/lib.rs @@ -685,7 +685,7 @@ impl Visitor<'tcx> for EmbargoVisitor<'tcx> { hir::ItemKind::ForeignMod { items, .. } => { for foreign_item in items { if foreign_item.vis.node.is_pub() { - self.update(foreign_item.id.hir_id, item_level); + self.update(foreign_item.id.hir_id(), item_level); } } } @@ -800,9 +800,9 @@ impl Visitor<'tcx> for EmbargoVisitor<'tcx> { // Visit everything, but foreign items have their own levels. hir::ItemKind::ForeignMod { items, .. } => { for foreign_item in items { - let foreign_item_level = self.get(foreign_item.id.hir_id); + let foreign_item_level = self.get(foreign_item.id.hir_id()); if foreign_item_level.is_some() { - self.reach(foreign_item.id.hir_id, foreign_item_level) + self.reach(foreign_item.id.hir_id(), foreign_item_level) .generics() .predicates() .ty(); @@ -1653,7 +1653,7 @@ impl<'a, 'tcx> Visitor<'tcx> for ObsoleteVisiblePrivateTypesVisitor<'a, 'tcx> { } fn visit_foreign_item(&mut self, item: &'tcx hir::ForeignItem<'tcx>) { - if self.access_levels.is_reachable(item.hir_id) { + if self.access_levels.is_reachable(item.hir_id()) { intravisit::walk_foreign_item(self, item) } } @@ -1982,8 +1982,8 @@ impl<'a, 'tcx> Visitor<'tcx> for PrivateItemsInPublicInterfacesVisitor<'a, 'tcx> // Subitems of foreign modules have their own publicity. hir::ItemKind::ForeignMod { items, .. } => { for foreign_item in items { - let vis = tcx.visibility(tcx.hir().local_def_id(foreign_item.id.hir_id)); - self.check(foreign_item.id.hir_id, vis).generics().predicates().ty(); + let vis = tcx.visibility(foreign_item.id.def_id); + self.check(foreign_item.id.hir_id(), vis).generics().predicates().ty(); } } // Subitems of structs and unions have their own publicity. diff --git a/compiler/rustc_save_analysis/src/dump_visitor.rs b/compiler/rustc_save_analysis/src/dump_visitor.rs index e9dbed20e44e1..625d7c831202b 100644 --- a/compiler/rustc_save_analysis/src/dump_visitor.rs +++ b/compiler/rustc_save_analysis/src/dump_visitor.rs @@ -1449,14 +1449,14 @@ impl<'tcx> Visitor<'tcx> for DumpVisitor<'tcx> { } fn visit_foreign_item(&mut self, item: &'tcx hir::ForeignItem<'tcx>) { - let access = access_from!(self.save_ctxt, item, item.hir_id); + let access = access_from!(self.save_ctxt, item, item.hir_id()); match item.kind { hir::ForeignItemKind::Fn(decl, _, ref generics) => { if let Some(fn_data) = self.save_ctxt.get_extern_item_data(item) { down_cast_data!(fn_data, DefData, item.span); - self.process_generic_params(generics, &fn_data.qualname, item.hir_id); + self.process_generic_params(generics, &fn_data.qualname, item.hir_id()); self.dumper.dump_def(&access, fn_data); } diff --git a/compiler/rustc_save_analysis/src/lib.rs b/compiler/rustc_save_analysis/src/lib.rs index 5801926968a64..b3f281bcabcec 100644 --- a/compiler/rustc_save_analysis/src/lib.rs +++ b/compiler/rustc_save_analysis/src/lib.rs @@ -137,7 +137,7 @@ impl<'tcx> SaveContext<'tcx> { } pub fn get_extern_item_data(&self, item: &hir::ForeignItem<'_>) -> Option { - let def_id = self.tcx.hir().local_def_id(item.hir_id).to_def_id(); + let def_id = item.def_id.to_def_id(); let qualname = format!("::{}", self.tcx.def_path_str(def_id)); match item.kind { hir::ForeignItemKind::Fn(ref decl, arg_names, ref generics) => { @@ -156,7 +156,7 @@ impl<'tcx> SaveContext<'tcx> { unsafety: hir::Unsafety::Unsafe, // functions in extern block cannot be const constness: hir::Constness::NotConst, - abi: self.tcx.hir().get_foreign_abi(item.hir_id), + abi: self.tcx.hir().get_foreign_abi(item.hir_id()), // functions in extern block cannot be async asyncness: hir::IsAsync::NotAsync, }, diff --git a/compiler/rustc_save_analysis/src/sig.rs b/compiler/rustc_save_analysis/src/sig.rs index a1fee58629a55..33db189af37a6 100644 --- a/compiler/rustc_save_analysis/src/sig.rs +++ b/compiler/rustc_save_analysis/src/sig.rs @@ -736,14 +736,14 @@ impl<'hir> Sig for hir::Variant<'hir> { impl<'hir> Sig for hir::ForeignItem<'hir> { fn make(&self, offset: usize, _parent_id: Option, scx: &SaveContext<'_>) -> Result { - let id = Some(self.hir_id); + let id = Some(self.hir_id()); match self.kind { hir::ForeignItemKind::Fn(decl, _, ref generics) => { let mut text = String::new(); text.push_str("fn "); let mut sig = - name_and_generics(text, offset, generics, self.hir_id, self.ident, scx)?; + name_and_generics(text, offset, generics, self.hir_id(), self.ident, scx)?; sig.text.push('('); for i in decl.inputs { @@ -774,7 +774,7 @@ impl<'hir> Sig for hir::ForeignItem<'hir> { } let name = self.ident.to_string(); let defs = vec![SigElement { - id: id_from_hir_id(self.hir_id, scx), + id: id_from_def_id(self.def_id.to_def_id()), start: offset + text.len(), end: offset + text.len() + name.len(), }]; @@ -790,7 +790,7 @@ impl<'hir> Sig for hir::ForeignItem<'hir> { let mut text = "type ".to_owned(); let name = self.ident.to_string(); let defs = vec![SigElement { - id: id_from_hir_id(self.hir_id, scx), + id: id_from_def_id(self.def_id.to_def_id()), start: offset + text.len(), end: offset + text.len() + name.len(), }]; diff --git a/compiler/rustc_symbol_mangling/src/test.rs b/compiler/rustc_symbol_mangling/src/test.rs index b46bb39b1f715..b1af95a3ab92c 100644 --- a/compiler/rustc_symbol_mangling/src/test.rs +++ b/compiler/rustc_symbol_mangling/src/test.rs @@ -73,6 +73,6 @@ impl hir::itemlikevisit::ItemLikeVisitor<'tcx> for SymbolNamesTest<'tcx> { } fn visit_foreign_item(&mut self, foreign_item: &'tcx hir::ForeignItem<'tcx>) { - self.process_attrs(foreign_item.hir_id); + self.process_attrs(foreign_item.hir_id()); } } diff --git a/compiler/rustc_typeck/src/check/check.rs b/compiler/rustc_typeck/src/check/check.rs index 43da911a42f12..7729df6af349d 100644 --- a/compiler/rustc_typeck/src/check/check.rs +++ b/compiler/rustc_typeck/src/check/check.rs @@ -776,7 +776,7 @@ pub fn check_item_type<'tcx>(tcx: TyCtxt<'tcx>, it: &'tcx hir::Item<'tcx>) { } } else { for item in items { - let def_id = tcx.hir().local_def_id(item.id.hir_id); + let def_id = item.id.def_id; let generics = tcx.generics_of(def_id); let own_counts = generics.own_counts(); if generics.params.len() - own_counts.lifetimes != 0 { diff --git a/compiler/rustc_typeck/src/check/intrinsic.rs b/compiler/rustc_typeck/src/check/intrinsic.rs index e99db7a247c46..dedf96863eaf6 100644 --- a/compiler/rustc_typeck/src/check/intrinsic.rs +++ b/compiler/rustc_typeck/src/check/intrinsic.rs @@ -9,7 +9,6 @@ use crate::require_same_types; use rustc_errors::struct_span_err; use rustc_hir as hir; -use rustc_hir::def_id::DefId; use rustc_middle::traits::{ObligationCause, ObligationCauseCode}; use rustc_middle::ty::subst::Subst; use rustc_middle::ty::{self, TyCtxt}; @@ -21,7 +20,6 @@ use std::iter; fn equate_intrinsic_type<'tcx>( tcx: TyCtxt<'tcx>, it: &hir::ForeignItem<'_>, - def_id: DefId, n_tps: usize, sig: ty::PolyFnSig<'tcx>, ) { @@ -35,7 +33,7 @@ fn equate_intrinsic_type<'tcx>( } } - let i_n_tps = tcx.generics_of(def_id).own_counts().types; + let i_n_tps = tcx.generics_of(it.def_id).own_counts().types; if i_n_tps != n_tps { let span = match it.kind { hir::ForeignItemKind::Fn(_, _, ref generics) => generics.span, @@ -51,8 +49,8 @@ fn equate_intrinsic_type<'tcx>( } let fty = tcx.mk_fn_ptr(sig); - let cause = ObligationCause::new(it.span, it.hir_id, ObligationCauseCode::IntrinsicType); - require_same_types(tcx, &cause, tcx.mk_fn_ptr(tcx.fn_sig(def_id)), fty); + let cause = ObligationCause::new(it.span, it.hir_id(), ObligationCauseCode::IntrinsicType); + require_same_types(tcx, &cause, tcx.mk_fn_ptr(tcx.fn_sig(it.def_id)), fty); } /// Returns `true` if the given intrinsic is unsafe to call or not. @@ -100,8 +98,7 @@ pub fn intrinsic_operation_unsafety(intrinsic: Symbol) -> hir::Unsafety { /// and in `library/core/src/intrinsics.rs`. pub fn check_intrinsic_type(tcx: TyCtxt<'_>, it: &hir::ForeignItem<'_>) { let param = |n| tcx.mk_ty_param(n, Symbol::intern(&format!("P{}", n))); - let def_id = tcx.hir().local_def_id(it.hir_id).to_def_id(); - let intrinsic_name = tcx.item_name(def_id); + let intrinsic_name = tcx.item_name(it.def_id.to_def_id()); let name_str = intrinsic_name.as_str(); let mk_va_list_ty = |mutbl| { @@ -370,7 +367,7 @@ pub fn check_intrinsic_type(tcx: TyCtxt<'_>, it: &hir::ForeignItem<'_>) { }; let sig = tcx.mk_fn_sig(inputs.into_iter(), output, false, unsafety, Abi::RustIntrinsic); let sig = ty::Binder::bind(sig); - equate_intrinsic_type(tcx, it, def_id, n_tps, sig) + equate_intrinsic_type(tcx, it, n_tps, sig) } /// Type-check `extern "platform-intrinsic" { ... }` functions. @@ -380,7 +377,6 @@ pub fn check_platform_intrinsic_type(tcx: TyCtxt<'_>, it: &hir::ForeignItem<'_>) tcx.mk_ty_param(n, name) }; - let def_id = tcx.hir().local_def_id(it.hir_id).to_def_id(); let name = it.ident.name; let (n_tps, inputs, output) = match name { @@ -464,5 +460,5 @@ pub fn check_platform_intrinsic_type(tcx: TyCtxt<'_>, it: &hir::ForeignItem<'_>) Abi::PlatformIntrinsic, ); let sig = ty::Binder::dummy(sig); - equate_intrinsic_type(tcx, it, def_id, n_tps, sig) + equate_intrinsic_type(tcx, it, n_tps, sig) } diff --git a/compiler/rustc_typeck/src/check/wfcheck.rs b/compiler/rustc_typeck/src/check/wfcheck.rs index 0bdcee458d75a..00c6550835b43 100644 --- a/compiler/rustc_typeck/src/check/wfcheck.rs +++ b/compiler/rustc_typeck/src/check/wfcheck.rs @@ -154,10 +154,10 @@ pub fn check_item_well_formed(tcx: TyCtxt<'_>, def_id: LocalDefId) { let it = tcx.hir().foreign_item(it.id); match it.kind { hir::ForeignItemKind::Fn(ref decl, ..) => { - check_item_fn(tcx, it.hir_id, it.ident, it.span, decl) + check_item_fn(tcx, it.hir_id(), it.ident, it.span, decl) } hir::ForeignItemKind::Static(ref ty, ..) => { - check_item_type(tcx, it.hir_id, ty.span, true) + check_item_type(tcx, it.hir_id(), ty.span, true) } hir::ForeignItemKind::Type => (), } diff --git a/compiler/rustc_typeck/src/collect.rs b/compiler/rustc_typeck/src/collect.rs index 5ad575183086d..753ccb9485f38 100644 --- a/compiler/rustc_typeck/src/collect.rs +++ b/compiler/rustc_typeck/src/collect.rs @@ -728,12 +728,11 @@ fn convert_item(tcx: TyCtxt<'_>, item_id: hir::ItemId) { hir::ItemKind::ForeignMod { items, .. } => { for item in items { let item = tcx.hir().foreign_item(item.id); - let def_id = tcx.hir().local_def_id(item.hir_id); - tcx.ensure().generics_of(def_id); - tcx.ensure().type_of(def_id); - tcx.ensure().predicates_of(def_id); + tcx.ensure().generics_of(item.def_id); + tcx.ensure().type_of(item.def_id); + tcx.ensure().predicates_of(item.def_id); if let hir::ForeignItemKind::Fn(..) = item.kind { - tcx.ensure().fn_sig(def_id); + tcx.ensure().fn_sig(item.def_id); } } } diff --git a/compiler/rustc_typeck/src/variance/constraints.rs b/compiler/rustc_typeck/src/variance/constraints.rs index 61f3f957df84a..f5355ea042bdf 100644 --- a/compiler/rustc_typeck/src/variance/constraints.rs +++ b/compiler/rustc_typeck/src/variance/constraints.rs @@ -110,7 +110,7 @@ impl<'a, 'tcx, 'v> ItemLikeVisitor<'v> for ConstraintContext<'a, 'tcx> { fn visit_foreign_item(&mut self, foreign_item: &hir::ForeignItem<'_>) { if let hir::ForeignItemKind::Fn(..) = foreign_item.kind { - self.visit_node_helper(foreign_item.hir_id); + self.visit_node_helper(foreign_item.hir_id()); } } } diff --git a/compiler/rustc_typeck/src/variance/terms.rs b/compiler/rustc_typeck/src/variance/terms.rs index e60a1c4009c82..5d5baf78d33c3 100644 --- a/compiler/rustc_typeck/src/variance/terms.rs +++ b/compiler/rustc_typeck/src/variance/terms.rs @@ -171,7 +171,7 @@ impl<'a, 'tcx, 'v> ItemLikeVisitor<'v> for TermsContext<'a, 'tcx> { fn visit_foreign_item(&mut self, foreign_item: &hir::ForeignItem<'_>) { if let hir::ForeignItemKind::Fn(..) = foreign_item.kind { - self.add_inferreds_for_item(foreign_item.hir_id); + self.add_inferreds_for_item(foreign_item.hir_id()); } } } diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 688470dd6918a..53e7bf2f49252 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -2239,10 +2239,10 @@ fn clean_use_statement( impl Clean for (&hir::ForeignItem<'_>, Option) { fn clean(&self, cx: &DocContext<'_>) -> Item { let (item, renamed) = self; - cx.with_param_env(cx.tcx.hir().local_def_id(item.hir_id).to_def_id(), || { + cx.with_param_env(item.def_id.to_def_id(), || { let kind = match item.kind { hir::ForeignItemKind::Fn(ref decl, ref names, ref generics) => { - let abi = cx.tcx.hir().get_foreign_abi(item.hir_id); + let abi = cx.tcx.hir().get_foreign_abi(item.hir_id()); let (generics, decl) = enter_impl_trait(cx, || { (generics.clean(cx), (&**decl, &names[..]).clean(cx)) }); @@ -2264,7 +2264,7 @@ impl Clean for (&hir::ForeignItem<'_>, Option) { }; Item::from_hir_id_and_parts( - item.hir_id, + item.hir_id(), Some(renamed.unwrap_or(item.ident.name)), kind, cx, diff --git a/src/librustdoc/doctest.rs b/src/librustdoc/doctest.rs index be02b0050e8e9..0b22db7db0510 100644 --- a/src/librustdoc/doctest.rs +++ b/src/librustdoc/doctest.rs @@ -1080,9 +1080,15 @@ impl<'a, 'hir, 'tcx> intravisit::Visitor<'hir> for HirCollector<'a, 'hir, 'tcx> } fn visit_foreign_item(&mut self, item: &'hir hir::ForeignItem<'_>) { - self.visit_testable(item.ident.to_string(), &item.attrs, item.hir_id, item.span, |this| { - intravisit::walk_foreign_item(this, item); - }); + self.visit_testable( + item.ident.to_string(), + &item.attrs, + item.hir_id(), + item.span, + |this| { + intravisit::walk_foreign_item(this, item); + }, + ); } fn visit_variant( From 7878fa70d6ddac3528d6523ac732fade6e5ae93b Mon Sep 17 00:00:00 2001 From: Camille GILLOT Date: Sun, 31 Jan 2021 11:01:49 +0100 Subject: [PATCH 09/14] Fix E0657. --- compiler/rustc_resolve/src/late/lifetimes.rs | 32 ++++++++++++-------- 1 file changed, 20 insertions(+), 12 deletions(-) diff --git a/compiler/rustc_resolve/src/late/lifetimes.rs b/compiler/rustc_resolve/src/late/lifetimes.rs index 56e60d73fa851..c0e4a1bdf07a4 100644 --- a/compiler/rustc_resolve/src/late/lifetimes.rs +++ b/compiler/rustc_resolve/src/late/lifetimes.rs @@ -632,24 +632,32 @@ impl<'a, 'tcx> Visitor<'tcx> for LifetimeContext<'a, 'tcx> { let hir_id = self.tcx.hir().local_def_id_to_hir_id(def_id); // Ensure that the parent of the def is an item, not HRTB let parent_id = self.tcx.hir().get_parent_node(hir_id); - let parent_item_id = - hir::ItemId { def_id: parent_id.expect_owner() }; - let parent_impl_id = - hir::ImplItemId { def_id: parent_id.expect_owner() }; - let parent_trait_id = - hir::TraitItemId { def_id: parent_id.expect_owner() }; - let krate = self.tcx.hir().krate(); - - if !(krate.items.contains_key(&parent_item_id) - || krate.impl_items.contains_key(&parent_impl_id) - || krate.trait_items.contains_key(&parent_trait_id)) + let parent_is_item = if let Some(parent_def_id) = + parent_id.as_owner() { + let parent_item_id = hir::ItemId { def_id: parent_def_id }; + let parent_impl_id = hir::ImplItemId { def_id: parent_def_id }; + let parent_trait_id = + hir::TraitItemId { def_id: parent_def_id }; + let parent_foreign_id = + hir::ForeignItemId { def_id: parent_def_id }; + let krate = self.tcx.hir().krate(); + + krate.items.contains_key(&parent_item_id) + || krate.impl_items.contains_key(&parent_impl_id) + || krate.trait_items.contains_key(&parent_trait_id) + || krate.foreign_items.contains_key(&parent_foreign_id) + } else { + false + }; + + if !parent_is_item { struct_span_err!( self.tcx.sess, lifetime.span, E0657, "`impl Trait` can only capture lifetimes \ - bound at the fn or impl level" + bound at the fn or impl level" ) .emit(); self.uninsert_lifetime_on_error(lifetime, def.unwrap()); From ff14cac621ce63d848abf615e45acd86fec32f50 Mon Sep 17 00:00:00 2001 From: Camille GILLOT Date: Sun, 31 Jan 2021 17:58:57 +0100 Subject: [PATCH 10/14] Index Modules using their LocalDefId. --- compiler/rustc_ast_lowering/src/item.rs | 6 +++--- compiler/rustc_ast_lowering/src/lib.rs | 10 +++++----- compiler/rustc_hir/src/hir.rs | 2 +- compiler/rustc_interface/src/passes.rs | 19 ++++++++----------- compiler/rustc_lint/src/late.rs | 2 +- compiler/rustc_middle/src/hir/mod.rs | 6 +----- compiler/rustc_passes/src/hir_id_validator.rs | 9 +++------ compiler/rustc_typeck/src/impl_wf_check.rs | 2 +- compiler/rustc_typeck/src/lib.rs | 4 ++-- src/librustdoc/core.rs | 5 ++--- 10 files changed, 27 insertions(+), 38 deletions(-) diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs index f88c73aee53c8..4a0c445990565 100644 --- a/compiler/rustc_ast_lowering/src/item.rs +++ b/compiler/rustc_ast_lowering/src/item.rs @@ -35,10 +35,10 @@ impl ItemLowerer<'_, '_, '_> { impl<'a> Visitor<'a> for ItemLowerer<'a, '_, '_> { fn visit_mod(&mut self, m: &'a Mod, _s: Span, _attrs: &[Attribute], n: NodeId) { - let hir_id = self.lctx.lower_node_id(n); + let def_id = self.lctx.lower_node_id(n).expect_owner(); self.lctx.modules.insert( - hir_id, + def_id, hir::ModuleItems { items: BTreeSet::new(), trait_items: BTreeSet::new(), @@ -48,7 +48,7 @@ impl<'a> Visitor<'a> for ItemLowerer<'a, '_, '_> { ); let old = self.lctx.current_module; - self.lctx.current_module = hir_id; + self.lctx.current_module = def_id; visit::walk_mod(self, m); self.lctx.current_module = old; } diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs index 3cb214464c024..8a12206a4c2f7 100644 --- a/compiler/rustc_ast_lowering/src/lib.rs +++ b/compiler/rustc_ast_lowering/src/lib.rs @@ -48,7 +48,7 @@ use rustc_data_structures::sync::Lrc; use rustc_errors::struct_span_err; use rustc_hir as hir; use rustc_hir::def::{DefKind, Namespace, PartialRes, PerNS, Res}; -use rustc_hir::def_id::{DefId, DefIdMap, LocalDefId, CRATE_DEF_INDEX}; +use rustc_hir::def_id::{DefId, DefIdMap, LocalDefId, CRATE_DEF_ID}; use rustc_hir::definitions::{DefKey, DefPathData, Definitions}; use rustc_hir::intravisit; use rustc_hir::{ConstArg, GenericArg, ParamName}; @@ -110,7 +110,7 @@ struct LoweringContext<'a, 'hir: 'a> { trait_impls: BTreeMap>, - modules: BTreeMap, + modules: BTreeMap, generator_kind: Option, @@ -158,7 +158,7 @@ struct LoweringContext<'a, 'hir: 'a> { /// vector. in_scope_lifetimes: Vec, - current_module: hir::HirId, + current_module: LocalDefId, type_def_lifetime_params: DefIdMap, @@ -314,8 +314,8 @@ pub fn lower_crate<'a, 'hir>( is_in_dyn_type: false, anonymous_lifetime_mode: AnonymousLifetimeMode::PassThrough, type_def_lifetime_params: Default::default(), - current_module: hir::CRATE_HIR_ID, - current_hir_id_owner: vec![(LocalDefId { local_def_index: CRATE_DEF_INDEX }, 0)], + current_module: CRATE_DEF_ID, + current_hir_id_owner: vec![(CRATE_DEF_ID, 0)], item_local_id_counters: Default::default(), node_id_to_hir_id: IndexVec::new(), generator_kind: None, diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs index a0950958455af..c9c670fdd4415 100644 --- a/compiler/rustc_hir/src/hir.rs +++ b/compiler/rustc_hir/src/hir.rs @@ -668,7 +668,7 @@ pub struct Crate<'hir> { /// A list of modules written out in the order in which they /// appear in the crate. This includes the main crate module. - pub modules: BTreeMap, + pub modules: BTreeMap, /// A list of proc macro HirIds, written out in the order in which /// they are declared in the static array generated by proc_macro_harness. pub proc_macros: Vec, diff --git a/compiler/rustc_interface/src/passes.rs b/compiler/rustc_interface/src/passes.rs index 56aa3939b22dc..544da4cd9aa7d 100644 --- a/compiler/rustc_interface/src/passes.rs +++ b/compiler/rustc_interface/src/passes.rs @@ -831,12 +831,11 @@ fn analysis(tcx: TyCtxt<'_>, cnum: CrateNum) -> Result<()> { }, { par_iter(&tcx.hir().krate().modules).for_each(|(&module, _)| { - let local_def_id = tcx.hir().local_def_id(module); - tcx.ensure().check_mod_loops(local_def_id); - tcx.ensure().check_mod_attrs(local_def_id); - tcx.ensure().check_mod_naked_functions(local_def_id); - tcx.ensure().check_mod_unstable_api_usage(local_def_id); - tcx.ensure().check_mod_const_bodies(local_def_id); + tcx.ensure().check_mod_loops(module); + tcx.ensure().check_mod_attrs(module); + tcx.ensure().check_mod_naked_functions(module); + tcx.ensure().check_mod_unstable_api_usage(module); + tcx.ensure().check_mod_const_bodies(module); }); } ); @@ -861,10 +860,8 @@ fn analysis(tcx: TyCtxt<'_>, cnum: CrateNum) -> Result<()> { // "not all control paths return a value" is reported here. // // maybe move the check to a MIR pass? - let local_def_id = tcx.hir().local_def_id(module); - - tcx.ensure().check_mod_liveness(local_def_id); - tcx.ensure().check_mod_intrinsics(local_def_id); + tcx.ensure().check_mod_liveness(module); + tcx.ensure().check_mod_intrinsics(module); }); }); } @@ -926,7 +923,7 @@ fn analysis(tcx: TyCtxt<'_>, cnum: CrateNum) -> Result<()> { { sess.time("privacy_checking_modules", || { par_iter(&tcx.hir().krate().modules).for_each(|(&module, _)| { - tcx.ensure().check_mod_privacy(tcx.hir().local_def_id(module)); + tcx.ensure().check_mod_privacy(module); }); }); } diff --git a/compiler/rustc_lint/src/late.rs b/compiler/rustc_lint/src/late.rs index c76f8eea201c8..e019b621aa359 100644 --- a/compiler/rustc_lint/src/late.rs +++ b/compiler/rustc_lint/src/late.rs @@ -496,7 +496,7 @@ pub fn check_crate<'tcx, T: LateLintPass<'tcx>>( tcx.sess.time("module_lints", || { // Run per-module lints par_iter(&tcx.hir().krate().modules).for_each(|(&module, _)| { - tcx.ensure().lint_mod(tcx.hir().local_def_id(module)); + tcx.ensure().lint_mod(module); }); }); }, diff --git a/compiler/rustc_middle/src/hir/mod.rs b/compiler/rustc_middle/src/hir/mod.rs index 6934e06d4c2e3..5f9cf8771eada 100644 --- a/compiler/rustc_middle/src/hir/mod.rs +++ b/compiler/rustc_middle/src/hir/mod.rs @@ -73,11 +73,7 @@ pub fn provide(providers: &mut Providers) { }; providers.hir_crate = |tcx, _| tcx.untracked_crate; providers.index_hir = map::index_hir; - providers.hir_module_items = |tcx, id| { - let hir = tcx.hir(); - let module = hir.local_def_id_to_hir_id(id); - &tcx.untracked_crate.modules[&module] - }; + providers.hir_module_items = |tcx, id| &tcx.untracked_crate.modules[&id]; providers.hir_owner = |tcx, id| tcx.index_hir(LOCAL_CRATE).map[id].signature; providers.hir_owner_nodes = |tcx, id| tcx.index_hir(LOCAL_CRATE).map[id].with_bodies.as_deref(); providers.def_span = |tcx, def_id| tcx.hir().span_if_local(def_id).unwrap_or(DUMMY_SP); diff --git a/compiler/rustc_passes/src/hir_id_validator.rs b/compiler/rustc_passes/src/hir_id_validator.rs index 0f1ff71cc2f29..79e3b5952acaf 100644 --- a/compiler/rustc_passes/src/hir_id_validator.rs +++ b/compiler/rustc_passes/src/hir_id_validator.rs @@ -14,12 +14,9 @@ pub fn check_crate(tcx: TyCtxt<'_>) { let errors = Lock::new(Vec::new()); let hir_map = tcx.hir(); - par_iter(&hir_map.krate().modules).for_each(|(module_id, _)| { - let local_def_id = hir_map.local_def_id(*module_id); - hir_map.visit_item_likes_in_module( - local_def_id, - &mut OuterVisitor { hir_map, errors: &errors }, - ); + par_iter(&hir_map.krate().modules).for_each(|(&module_id, _)| { + hir_map + .visit_item_likes_in_module(module_id, &mut OuterVisitor { hir_map, errors: &errors }); }); let errors = errors.into_inner(); diff --git a/compiler/rustc_typeck/src/impl_wf_check.rs b/compiler/rustc_typeck/src/impl_wf_check.rs index d8ae0e42546a6..7713381e62e46 100644 --- a/compiler/rustc_typeck/src/impl_wf_check.rs +++ b/compiler/rustc_typeck/src/impl_wf_check.rs @@ -59,7 +59,7 @@ pub fn impl_wf_check(tcx: TyCtxt<'_>) { // but it's one that we must perform earlier than the rest of // WfCheck. for &module in tcx.hir().krate().modules.keys() { - tcx.ensure().check_mod_impl_wf(tcx.hir().local_def_id(module)); + tcx.ensure().check_mod_impl_wf(module); } } diff --git a/compiler/rustc_typeck/src/lib.rs b/compiler/rustc_typeck/src/lib.rs index 22d95b8bcc08f..6ddc26efeae35 100644 --- a/compiler/rustc_typeck/src/lib.rs +++ b/compiler/rustc_typeck/src/lib.rs @@ -369,7 +369,7 @@ pub fn check_crate(tcx: TyCtxt<'_>) -> Result<(), ErrorReported> { tcx.sess.track_errors(|| { tcx.sess.time("type_collecting", || { for &module in tcx.hir().krate().modules.keys() { - tcx.ensure().collect_mod_item_types(tcx.hir().local_def_id(module)); + tcx.ensure().collect_mod_item_types(module); } }); })?; @@ -401,7 +401,7 @@ pub fn check_crate(tcx: TyCtxt<'_>) -> Result<(), ErrorReported> { // NOTE: This is copy/pasted in librustdoc/core.rs and should be kept in sync. tcx.sess.time("item_types_checking", || { for &module in tcx.hir().krate().modules.keys() { - tcx.ensure().check_mod_item_types(tcx.hir().local_def_id(module)); + tcx.ensure().check_mod_item_types(module); } }); diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs index a20e9dec33b36..d79c47bbe3de6 100644 --- a/src/librustdoc/core.rs +++ b/src/librustdoc/core.rs @@ -479,7 +479,7 @@ crate fn run_global_ctxt( // NOTE: This is copy/pasted from typeck/lib.rs and should be kept in sync with those changes. tcx.sess.time("item_types_checking", || { for &module in tcx.hir().krate().modules.keys() { - tcx.ensure().check_mod_item_types(tcx.hir().local_def_id(module)); + tcx.ensure().check_mod_item_types(module); } }); tcx.sess.abort_if_errors(); @@ -488,8 +488,7 @@ crate fn run_global_ctxt( }); tcx.sess.time("check_mod_attrs", || { for &module in tcx.hir().krate().modules.keys() { - let local_def_id = tcx.hir().local_def_id(module); - tcx.ensure().check_mod_attrs(local_def_id); + tcx.ensure().check_mod_attrs(module); } }); From c4e74270819a7615a577c90f7616b422bc07eb21 Mon Sep 17 00:00:00 2001 From: Camille GILLOT Date: Sun, 31 Jan 2021 18:20:18 +0100 Subject: [PATCH 11/14] Only store a LocalDefId in hir::MacroDef. --- compiler/rustc_ast_lowering/src/item.rs | 4 ++-- compiler/rustc_hir/src/hir.rs | 14 ++++++++++---- compiler/rustc_hir/src/intravisit.rs | 2 +- compiler/rustc_hir/src/stable_hash_impls.rs | 18 ++++++++++++++++-- compiler/rustc_lint/src/levels.rs | 2 +- compiler/rustc_metadata/src/rmeta/encoder.rs | 2 +- compiler/rustc_middle/src/hir/map/collector.rs | 6 +++--- compiler/rustc_middle/src/hir/map/mod.rs | 2 +- compiler/rustc_passes/src/check_attr.rs | 2 +- compiler/rustc_passes/src/diagnostic_items.rs | 2 +- compiler/rustc_passes/src/hir_stats.rs | 2 +- compiler/rustc_passes/src/stability.rs | 4 ++-- compiler/rustc_privacy/src/lib.rs | 8 +++----- src/librustdoc/clean/mod.rs | 4 ++-- src/librustdoc/doctest.rs | 2 +- src/librustdoc/visit_ast.rs | 2 +- 16 files changed, 47 insertions(+), 29 deletions(-) diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs index 4a0c445990565..5a1754751bfd9 100644 --- a/compiler/rustc_ast_lowering/src/item.rs +++ b/compiler/rustc_ast_lowering/src/item.rs @@ -234,13 +234,13 @@ impl<'hir> LoweringContext<'_, 'hir> { if let ItemKind::MacroDef(MacroDef { ref body, macro_rules }) = i.kind { if !macro_rules || self.sess.contains_name(&i.attrs, sym::macro_export) { - let hir_id = self.lower_node_id(i.id); + let def_id = self.lower_node_id(i.id).expect_owner(); let body = P(self.lower_mac_args(body)); self.exported_macros.push(hir::MacroDef { ident, vis, attrs, - hir_id, + def_id, span: i.span, ast: MacroDef { body, macro_rules }, }); diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs index c9c670fdd4415..e95f31a1fe80e 100644 --- a/compiler/rustc_hir/src/hir.rs +++ b/compiler/rustc_hir/src/hir.rs @@ -761,16 +761,22 @@ impl Crate<'_> { /// A macro definition, in this crate or imported from another. /// /// Not parsed directly, but created on macro import or `macro_rules!` expansion. -#[derive(Debug, HashStable_Generic)] +#[derive(Debug)] pub struct MacroDef<'hir> { pub ident: Ident, pub vis: Visibility<'hir>, pub attrs: &'hir [Attribute], - pub hir_id: HirId, + pub def_id: LocalDefId, pub span: Span, pub ast: ast::MacroDef, } +impl MacroDef<'_> { + pub fn hir_id(&self) -> HirId { + HirId::make_owner(self.def_id) + } +} + /// A block of statements `{ .. }`, which may have a label (in this case the /// `targeted_by_break` field will be `true`) and may be `unsafe` by means of /// the `rules` being anything but `DefaultBlock`. @@ -2941,7 +2947,8 @@ impl<'hir> Node<'hir> { Node::Item(Item { def_id, .. }) | Node::TraitItem(TraitItem { def_id, .. }) | Node::ImplItem(ImplItem { def_id, .. }) - | Node::ForeignItem(ForeignItem { def_id, .. }) => Some(HirId::make_owner(*def_id)), + | Node::ForeignItem(ForeignItem { def_id, .. }) + | Node::MacroDef(MacroDef { def_id, .. }) => Some(HirId::make_owner(*def_id)), Node::Field(StructField { hir_id, .. }) | Node::AnonConst(AnonConst { hir_id, .. }) | Node::Expr(Expr { hir_id, .. }) @@ -2952,7 +2959,6 @@ impl<'hir> Node<'hir> { | Node::Arm(Arm { hir_id, .. }) | Node::Block(Block { hir_id, .. }) | Node::Local(Local { hir_id, .. }) - | Node::MacroDef(MacroDef { hir_id, .. }) | Node::Lifetime(Lifetime { hir_id, .. }) | Node::Param(Param { hir_id, .. }) | Node::GenericParam(GenericParam { hir_id, .. }) => Some(*hir_id), diff --git a/compiler/rustc_hir/src/intravisit.rs b/compiler/rustc_hir/src/intravisit.rs index c59464a0cb6fc..6a2719c2d6677 100644 --- a/compiler/rustc_hir/src/intravisit.rs +++ b/compiler/rustc_hir/src/intravisit.rs @@ -489,7 +489,7 @@ pub fn walk_crate<'v, V: Visitor<'v>>(visitor: &mut V, krate: &'v Crate<'v>) { } pub fn walk_macro_def<'v, V: Visitor<'v>>(visitor: &mut V, macro_def: &'v MacroDef<'v>) { - visitor.visit_id(macro_def.hir_id); + visitor.visit_id(macro_def.hir_id()); visitor.visit_ident(macro_def.ident); walk_list!(visitor, visit_attribute, macro_def.attrs); } diff --git a/compiler/rustc_hir/src/stable_hash_impls.rs b/compiler/rustc_hir/src/stable_hash_impls.rs index 091e1ed9971c2..5fb4b8a58c210 100644 --- a/compiler/rustc_hir/src/stable_hash_impls.rs +++ b/compiler/rustc_hir/src/stable_hash_impls.rs @@ -1,8 +1,8 @@ use rustc_data_structures::stable_hasher::{HashStable, StableHasher, ToStableHashKey}; use crate::hir::{ - BodyId, Expr, ForeignItem, ForeignItemId, ImplItem, ImplItemId, Item, ItemId, Mod, TraitItem, - TraitItemId, Ty, VisibilityKind, + BodyId, Expr, ForeignItem, ForeignItemId, ImplItem, ImplItemId, Item, ItemId, MacroDef, Mod, + TraitItem, TraitItemId, Ty, VisibilityKind, }; use crate::hir_id::{HirId, ItemLocalId}; use rustc_span::def_id::{DefPathHash, LocalDefId}; @@ -203,3 +203,17 @@ impl HashStable for Item<'_> { }); } } + +impl HashStable for MacroDef<'_> { + fn hash_stable(&self, hcx: &mut HirCtx, hasher: &mut StableHasher) { + let MacroDef { ident, ref attrs, def_id: _, ref ast, ref vis, span } = *self; + + hcx.hash_hir_item_like(|hcx| { + ident.name.hash_stable(hcx, hasher); + attrs.hash_stable(hcx, hasher); + ast.hash_stable(hcx, hasher); + vis.hash_stable(hcx, hasher); + span.hash_stable(hcx, hasher); + }); + } +} diff --git a/compiler/rustc_lint/src/levels.rs b/compiler/rustc_lint/src/levels.rs index a06e9e5dce681..cc5b7ef098756 100644 --- a/compiler/rustc_lint/src/levels.rs +++ b/compiler/rustc_lint/src/levels.rs @@ -41,7 +41,7 @@ fn lint_levels(tcx: TyCtxt<'_>, cnum: CrateNum) -> LintLevelMap { let push = builder.levels.push(&krate.item.attrs, &store, true); builder.levels.register_id(hir::CRATE_HIR_ID); for macro_def in krate.exported_macros { - builder.levels.register_id(macro_def.hir_id); + builder.levels.register_id(macro_def.hir_id()); } intravisit::walk_crate(&mut builder, krate); builder.levels.pop(push); diff --git a/compiler/rustc_metadata/src/rmeta/encoder.rs b/compiler/rustc_metadata/src/rmeta/encoder.rs index 905b0b37cf788..1306aa49dbc3c 100644 --- a/compiler/rustc_metadata/src/rmeta/encoder.rs +++ b/compiler/rustc_metadata/src/rmeta/encoder.rs @@ -1494,7 +1494,7 @@ impl EncodeContext<'a, 'tcx> { /// Serialize the text of exported macros fn encode_info_for_macro_def(&mut self, macro_def: &hir::MacroDef<'_>) { - let def_id = self.tcx.hir().local_def_id(macro_def.hir_id).to_def_id(); + let def_id = macro_def.def_id.to_def_id(); record!(self.tables.kind[def_id] <- EntryKind::MacroDef(self.lazy(macro_def.ast.clone()))); self.encode_ident_span(def_id, macro_def.ident); } diff --git a/compiler/rustc_middle/src/hir/map/collector.rs b/compiler/rustc_middle/src/hir/map/collector.rs index 11d8202633521..b9fb3142c633e 100644 --- a/compiler/rustc_middle/src/hir/map/collector.rs +++ b/compiler/rustc_middle/src/hir/map/collector.rs @@ -517,15 +517,15 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> { // Exported macros are visited directly from the crate root, // so they do not have `parent_node` set. // Find the correct enclosing module from their DefKey. - let def_key = self.definitions.def_key(macro_def.hir_id.owner); + let def_key = self.definitions.def_key(macro_def.def_id); let parent = def_key.parent.map_or(hir::CRATE_HIR_ID, |local_def_index| { self.definitions.local_def_id_to_hir_id(LocalDefId { local_def_index }) }); self.with_parent(parent, |this| { - this.with_dep_node_owner(macro_def.hir_id.owner, macro_def, |this, hash| { + this.with_dep_node_owner(macro_def.def_id, macro_def, |this, hash| { this.insert_with_hash( macro_def.span, - macro_def.hir_id, + macro_def.hir_id(), Node::MacroDef(macro_def), hash, ); diff --git a/compiler/rustc_middle/src/hir/map/mod.rs b/compiler/rustc_middle/src/hir/map/mod.rs index c4f469ca7f441..35f7fa0f6d741 100644 --- a/compiler/rustc_middle/src/hir/map/mod.rs +++ b/compiler/rustc_middle/src/hir/map/mod.rs @@ -500,7 +500,7 @@ impl<'hir> Map<'hir> { V: Visitor<'hir>, { for id in self.krate().exported_macros { - visitor.visit_macro_def(self.expect_macro_def(id.hir_id)); + visitor.visit_macro_def(self.expect_macro_def(id.hir_id())); } } diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs index f5ab4273e713e..bf9b7e588bd4b 100644 --- a/compiler/rustc_passes/src/check_attr.rs +++ b/compiler/rustc_passes/src/check_attr.rs @@ -1155,7 +1155,7 @@ impl Visitor<'tcx> for CheckAttrVisitor<'tcx> { fn visit_macro_def(&mut self, macro_def: &'tcx hir::MacroDef<'tcx>) { self.check_attributes( - macro_def.hir_id, + macro_def.hir_id(), macro_def.attrs, ¯o_def.span, Target::MacroDef, diff --git a/compiler/rustc_passes/src/diagnostic_items.rs b/compiler/rustc_passes/src/diagnostic_items.rs index 496973947ca90..29e99203fddc3 100644 --- a/compiler/rustc_passes/src/diagnostic_items.rs +++ b/compiler/rustc_passes/src/diagnostic_items.rs @@ -106,7 +106,7 @@ fn collect<'tcx>(tcx: TyCtxt<'tcx>) -> FxHashMap { tcx.hir().krate().visit_all_item_likes(&mut collector); for m in tcx.hir().krate().exported_macros { - collector.observe_item(m.attrs, m.hir_id); + collector.observe_item(m.attrs, m.hir_id()); } collector.items diff --git a/compiler/rustc_passes/src/hir_stats.rs b/compiler/rustc_passes/src/hir_stats.rs index 9e1a3c61628a4..e35ad10968d33 100644 --- a/compiler/rustc_passes/src/hir_stats.rs +++ b/compiler/rustc_passes/src/hir_stats.rs @@ -246,7 +246,7 @@ impl<'v> hir_visit::Visitor<'v> for StatCollector<'v> { } fn visit_macro_def(&mut self, macro_def: &'v hir::MacroDef<'v>) { - self.record("MacroDef", Id::Node(macro_def.hir_id), macro_def); + self.record("MacroDef", Id::Node(macro_def.hir_id()), macro_def); hir_visit::walk_macro_def(self, macro_def) } } diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs index 0569e7fa3ab92..f538427efd9ff 100644 --- a/compiler/rustc_passes/src/stability.rs +++ b/compiler/rustc_passes/src/stability.rs @@ -473,7 +473,7 @@ impl<'a, 'tcx> Visitor<'tcx> for Annotator<'a, 'tcx> { fn visit_macro_def(&mut self, md: &'tcx hir::MacroDef<'tcx>) { self.annotate( - md.hir_id, + md.hir_id(), &md.attrs, md.span, AnnotationKind::Required, @@ -599,7 +599,7 @@ impl<'tcx> Visitor<'tcx> for MissingStabilityAnnotations<'tcx> { } fn visit_macro_def(&mut self, md: &'tcx hir::MacroDef<'tcx>) { - self.check_missing_stability(md.hir_id, md.span); + self.check_missing_stability(md.hir_id(), md.span); } // Note that we don't need to `check_missing_stability` for default generic parameters, diff --git a/compiler/rustc_privacy/src/lib.rs b/compiler/rustc_privacy/src/lib.rs index a7327fb012f33..890493fa85387 100644 --- a/compiler/rustc_privacy/src/lib.rs +++ b/compiler/rustc_privacy/src/lib.rs @@ -867,14 +867,12 @@ impl Visitor<'tcx> for EmbargoVisitor<'tcx> { // `#[macro_export]`-ed `macro_rules!` are `Public` since they // ignore their containing path to always appear at the crate root. if md.ast.macro_rules { - self.update(md.hir_id, Some(AccessLevel::Public)); + self.update(md.hir_id(), Some(AccessLevel::Public)); } return; } - let macro_module_def_id = - ty::DefIdTree::parent(self.tcx, self.tcx.hir().local_def_id(md.hir_id).to_def_id()) - .unwrap(); + let macro_module_def_id = ty::DefIdTree::parent(self.tcx, md.def_id.to_def_id()).unwrap(); let hir_id = macro_module_def_id .as_local() .map(|def_id| self.tcx.hir().local_def_id_to_hir_id(def_id)); @@ -884,7 +882,7 @@ impl Visitor<'tcx> for EmbargoVisitor<'tcx> { _ => return, }; let level = if md.vis.node.is_pub() { self.get(module_id) } else { None }; - let new_level = self.update(md.hir_id, level); + let new_level = self.update(md.hir_id(), level); if new_level.is_none() { return; } diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index 53e7bf2f49252..99aea2e0c29df 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -2291,7 +2291,7 @@ impl Clean for (&hir::MacroDef<'_>, Option) { ) } else { let vis = item.vis.clean(cx); - let def_id = cx.tcx.hir().local_def_id(item.hir_id).to_def_id(); + let def_id = item.def_id.to_def_id(); if matchers.len() <= 1 { format!( @@ -2314,7 +2314,7 @@ impl Clean for (&hir::MacroDef<'_>, Option) { }; Item::from_hir_id_and_parts( - item.hir_id, + item.hir_id(), Some(name), MacroItem(Macro { source, imported_from: None }), cx, diff --git a/src/librustdoc/doctest.rs b/src/librustdoc/doctest.rs index 0b22db7db0510..c3b9fd5a1dd42 100644 --- a/src/librustdoc/doctest.rs +++ b/src/librustdoc/doctest.rs @@ -1112,7 +1112,7 @@ impl<'a, 'hir, 'tcx> intravisit::Visitor<'hir> for HirCollector<'a, 'hir, 'tcx> self.visit_testable( macro_def.ident.to_string(), ¯o_def.attrs, - macro_def.hir_id, + macro_def.hir_id(), macro_def.span, |_| (), ); diff --git a/src/librustdoc/visit_ast.rs b/src/librustdoc/visit_ast.rs index 73d096749f470..e92ea55caa737 100644 --- a/src/librustdoc/visit_ast.rs +++ b/src/librustdoc/visit_ast.rs @@ -89,7 +89,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> { // (since a direct parent isn't necessarily a module, c.f. #77828). let macro_parent_def_id = { use rustc_middle::ty::DefIdTree; - tcx.parent(tcx.hir().local_def_id(def.hir_id).to_def_id()).unwrap() + tcx.parent(def.def_id.to_def_id()).unwrap() }; let macro_parent_path = tcx.def_path(macro_parent_def_id); // HACK: rustdoc has no way to lookup `doctree::Module`s by their HirId. Instead, From f395f2ea120cad774a2d7396e0e2ab5667be3116 Mon Sep 17 00:00:00 2001 From: Camille GILLOT Date: Sun, 31 Jan 2021 18:21:04 +0100 Subject: [PATCH 12/14] Use less HirId when referring to items. --- .../src/persist/dirty_clean.rs | 28 +++++++++---------- compiler/rustc_passes/src/diagnostic_items.rs | 15 +++++----- compiler/rustc_symbol_mangling/src/test.rs | 12 ++++---- 3 files changed, 27 insertions(+), 28 deletions(-) diff --git a/compiler/rustc_incremental/src/persist/dirty_clean.rs b/compiler/rustc_incremental/src/persist/dirty_clean.rs index 752431247f064..8a83149d73235 100644 --- a/compiler/rustc_incremental/src/persist/dirty_clean.rs +++ b/compiler/rustc_incremental/src/persist/dirty_clean.rs @@ -17,7 +17,7 @@ use rustc_ast::{self as ast, Attribute, NestedMetaItem}; use rustc_data_structures::fingerprint::Fingerprint; use rustc_data_structures::fx::FxHashSet; use rustc_hir as hir; -use rustc_hir::def_id::DefId; +use rustc_hir::def_id::{DefId, LocalDefId}; use rustc_hir::intravisit; use rustc_hir::itemlikevisit::ItemLikeVisitor; use rustc_hir::Node as HirNode; @@ -179,7 +179,7 @@ pub struct DirtyCleanVisitor<'tcx> { impl DirtyCleanVisitor<'tcx> { /// Possibly "deserialize" the attribute into a clean/dirty assertion - fn assertion_maybe(&mut self, item_id: hir::HirId, attr: &Attribute) -> Option { + fn assertion_maybe(&mut self, item_id: LocalDefId, attr: &Attribute) -> Option { let is_clean = if self.tcx.sess.check_name(attr, sym::rustc_dirty) { false } else if self.tcx.sess.check_name(attr, sym::rustc_clean) { @@ -207,7 +207,7 @@ impl DirtyCleanVisitor<'tcx> { /// Gets the "auto" assertion on pre-validated attr, along with the `except` labels. fn assertion_auto( &mut self, - item_id: hir::HirId, + item_id: LocalDefId, attr: &Attribute, is_clean: bool, ) -> Assertion { @@ -253,8 +253,9 @@ impl DirtyCleanVisitor<'tcx> { /// Return all DepNode labels that should be asserted for this item. /// index=0 is the "name" used for error messages - fn auto_labels(&mut self, item_id: hir::HirId, attr: &Attribute) -> (&'static str, Labels) { - let node = self.tcx.hir().get(item_id); + fn auto_labels(&mut self, item_id: LocalDefId, attr: &Attribute) -> (&'static str, Labels) { + let hir_id = self.tcx.hir().local_def_id_to_hir_id(item_id); + let node = self.tcx.hir().get(hir_id); let (name, labels) = match node { HirNode::Item(item) => { match item.kind { @@ -430,18 +431,17 @@ impl DirtyCleanVisitor<'tcx> { } } - fn check_item(&mut self, item_id: hir::HirId, item_span: Span) { - let def_id = self.tcx.hir().local_def_id(item_id); - for attr in self.tcx.get_attrs(def_id.to_def_id()).iter() { + fn check_item(&mut self, item_id: LocalDefId, item_span: Span) { + for attr in self.tcx.get_attrs(item_id.to_def_id()).iter() { let assertion = match self.assertion_maybe(item_id, attr) { Some(a) => a, None => continue, }; self.checked_attrs.insert(attr.id); - for dep_node in self.dep_nodes(&assertion.clean, def_id.to_def_id()) { + for dep_node in self.dep_nodes(&assertion.clean, item_id.to_def_id()) { self.assert_clean(item_span, dep_node); } - for dep_node in self.dep_nodes(&assertion.dirty, def_id.to_def_id()) { + for dep_node in self.dep_nodes(&assertion.dirty, item_id.to_def_id()) { self.assert_dirty(item_span, dep_node); } } @@ -450,19 +450,19 @@ impl DirtyCleanVisitor<'tcx> { impl ItemLikeVisitor<'tcx> for DirtyCleanVisitor<'tcx> { fn visit_item(&mut self, item: &'tcx hir::Item<'tcx>) { - self.check_item(item.hir_id(), item.span); + self.check_item(item.def_id, item.span); } fn visit_trait_item(&mut self, item: &hir::TraitItem<'_>) { - self.check_item(item.hir_id(), item.span); + self.check_item(item.def_id, item.span); } fn visit_impl_item(&mut self, item: &hir::ImplItem<'_>) { - self.check_item(item.hir_id(), item.span); + self.check_item(item.def_id, item.span); } fn visit_foreign_item(&mut self, item: &hir::ForeignItem<'_>) { - self.check_item(item.hir_id(), item.span); + self.check_item(item.def_id, item.span); } } diff --git a/compiler/rustc_passes/src/diagnostic_items.rs b/compiler/rustc_passes/src/diagnostic_items.rs index 29e99203fddc3..3ec7ea39248bf 100644 --- a/compiler/rustc_passes/src/diagnostic_items.rs +++ b/compiler/rustc_passes/src/diagnostic_items.rs @@ -16,7 +16,7 @@ use rustc_hir::itemlikevisit::ItemLikeVisitor; use rustc_middle::ty::query::Providers; use rustc_middle::ty::TyCtxt; use rustc_session::Session; -use rustc_span::def_id::{DefId, LOCAL_CRATE}; +use rustc_span::def_id::{DefId, LocalDefId, LOCAL_CRATE}; use rustc_span::symbol::{sym, Symbol}; struct DiagnosticItemCollector<'tcx> { @@ -27,19 +27,19 @@ struct DiagnosticItemCollector<'tcx> { impl<'v, 'tcx> ItemLikeVisitor<'v> for DiagnosticItemCollector<'tcx> { fn visit_item(&mut self, item: &hir::Item<'_>) { - self.observe_item(&item.attrs, item.hir_id()); + self.observe_item(&item.attrs, item.def_id); } fn visit_trait_item(&mut self, trait_item: &hir::TraitItem<'_>) { - self.observe_item(&trait_item.attrs, trait_item.hir_id()); + self.observe_item(&trait_item.attrs, trait_item.def_id); } fn visit_impl_item(&mut self, impl_item: &hir::ImplItem<'_>) { - self.observe_item(&impl_item.attrs, impl_item.hir_id()); + self.observe_item(&impl_item.attrs, impl_item.def_id); } fn visit_foreign_item(&mut self, foreign_item: &hir::ForeignItem<'_>) { - self.observe_item(foreign_item.attrs, foreign_item.hir_id()); + self.observe_item(foreign_item.attrs, foreign_item.def_id); } } @@ -48,9 +48,8 @@ impl<'tcx> DiagnosticItemCollector<'tcx> { DiagnosticItemCollector { tcx, items: Default::default() } } - fn observe_item(&mut self, attrs: &[ast::Attribute], hir_id: hir::HirId) { + fn observe_item(&mut self, attrs: &[ast::Attribute], def_id: LocalDefId) { if let Some(name) = extract(&self.tcx.sess, attrs) { - let def_id = self.tcx.hir().local_def_id(hir_id); // insert into our table collect_item(self.tcx, &mut self.items, name, def_id.to_def_id()); } @@ -106,7 +105,7 @@ fn collect<'tcx>(tcx: TyCtxt<'tcx>) -> FxHashMap { tcx.hir().krate().visit_all_item_likes(&mut collector); for m in tcx.hir().krate().exported_macros { - collector.observe_item(m.attrs, m.hir_id()); + collector.observe_item(m.attrs, m.def_id); } collector.items diff --git a/compiler/rustc_symbol_mangling/src/test.rs b/compiler/rustc_symbol_mangling/src/test.rs index b1af95a3ab92c..bfe9c4d6de3de 100644 --- a/compiler/rustc_symbol_mangling/src/test.rs +++ b/compiler/rustc_symbol_mangling/src/test.rs @@ -5,6 +5,7 @@ //! paths etc in all kinds of annoying scenarios. use rustc_hir as hir; +use rustc_hir::def_id::LocalDefId; use rustc_middle::ty::print::with_no_trimmed_paths; use rustc_middle::ty::{subst::InternalSubsts, Instance, TyCtxt}; use rustc_span::symbol::{sym, Symbol}; @@ -31,9 +32,8 @@ struct SymbolNamesTest<'tcx> { } impl SymbolNamesTest<'tcx> { - fn process_attrs(&mut self, hir_id: hir::HirId) { + fn process_attrs(&mut self, def_id: LocalDefId) { let tcx = self.tcx; - let def_id = tcx.hir().local_def_id(hir_id); for attr in tcx.get_attrs(def_id.to_def_id()).iter() { if tcx.sess.check_name(attr, SYMBOL_NAME) { let def_id = def_id.to_def_id(); @@ -61,18 +61,18 @@ impl SymbolNamesTest<'tcx> { impl hir::itemlikevisit::ItemLikeVisitor<'tcx> for SymbolNamesTest<'tcx> { fn visit_item(&mut self, item: &'tcx hir::Item<'tcx>) { - self.process_attrs(item.hir_id()); + self.process_attrs(item.def_id); } fn visit_trait_item(&mut self, trait_item: &'tcx hir::TraitItem<'tcx>) { - self.process_attrs(trait_item.hir_id()); + self.process_attrs(trait_item.def_id); } fn visit_impl_item(&mut self, impl_item: &'tcx hir::ImplItem<'tcx>) { - self.process_attrs(impl_item.hir_id()); + self.process_attrs(impl_item.def_id); } fn visit_foreign_item(&mut self, foreign_item: &'tcx hir::ForeignItem<'tcx>) { - self.process_attrs(foreign_item.hir_id()); + self.process_attrs(foreign_item.def_id); } } From 7dd1e8cfdf7f02010cc3d21eba59954255166484 Mon Sep 17 00:00:00 2001 From: Camille GILLOT Date: Mon, 1 Feb 2021 11:12:49 +0100 Subject: [PATCH 13/14] Trait impls are Items, therefore HIR owners. --- compiler/rustc_ast_lowering/src/item.rs | 8 +++----- compiler/rustc_ast_lowering/src/lib.rs | 2 +- compiler/rustc_hir/src/hir.rs | 2 +- .../nice_region_error/static_impl_trait.rs | 3 +-- compiler/rustc_middle/src/hir/map/mod.rs | 2 +- compiler/rustc_middle/src/query/mod.rs | 2 +- compiler/rustc_middle/src/ty/trait_def.rs | 9 ++++----- compiler/rustc_typeck/src/coherence/builtin.rs | 3 +-- compiler/rustc_typeck/src/coherence/mod.rs | 3 +-- src/librustdoc/passes/collect_trait_impls.rs | 4 ++-- 10 files changed, 16 insertions(+), 22 deletions(-) diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs index 5a1754751bfd9..9496689779b05 100644 --- a/compiler/rustc_ast_lowering/src/item.rs +++ b/compiler/rustc_ast_lowering/src/item.rs @@ -396,8 +396,6 @@ impl<'hir> LoweringContext<'_, 'hir> { self_ty: ref ty, items: ref impl_items, }) => { - let def_id = self.resolver.local_def_id(id); - // Lower the "impl header" first. This ordering is important // for in-band lifetimes! Consider `'a` here: // @@ -411,10 +409,10 @@ impl<'hir> LoweringContext<'_, 'hir> { // method, it will not be considered an in-band // lifetime to be added, but rather a reference to a // parent lifetime. - let lowered_trait_impl_id = self.lower_node_id(id); + let lowered_trait_def_id = self.lower_node_id(id).expect_owner(); let (generics, (trait_ref, lowered_ty)) = self.add_in_band_defs( ast_generics, - def_id, + lowered_trait_def_id, AnonymousLifetimeMode::CreateParameter, |this, _| { let trait_ref = trait_ref.as_ref().map(|trait_ref| { @@ -426,7 +424,7 @@ impl<'hir> LoweringContext<'_, 'hir> { this.trait_impls .entry(def_id) .or_default() - .push(lowered_trait_impl_id); + .push(lowered_trait_def_id); } } diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs index 8a12206a4c2f7..9d0b2cd5c675d 100644 --- a/compiler/rustc_ast_lowering/src/lib.rs +++ b/compiler/rustc_ast_lowering/src/lib.rs @@ -108,7 +108,7 @@ struct LoweringContext<'a, 'hir: 'a> { exported_macros: Vec>, non_exported_macro_attrs: Vec, - trait_impls: BTreeMap>, + trait_impls: BTreeMap>, modules: BTreeMap, diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs index e95f31a1fe80e..6ac1c570cfe1b 100644 --- a/compiler/rustc_hir/src/hir.rs +++ b/compiler/rustc_hir/src/hir.rs @@ -658,7 +658,7 @@ pub struct Crate<'hir> { pub impl_items: BTreeMap>, pub foreign_items: BTreeMap>, pub bodies: BTreeMap>, - pub trait_impls: BTreeMap>, + pub trait_impls: BTreeMap>, /// A list of the body ids written out in the order in which they /// appear in the crate. If you're going to process all the bodies diff --git a/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/static_impl_trait.rs b/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/static_impl_trait.rs index e88c827477e52..fa0d5b8301349 100644 --- a/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/static_impl_trait.rs +++ b/compiler/rustc_infer/src/infer/error_reporting/nice_region_error/static_impl_trait.rs @@ -361,8 +361,7 @@ impl<'a, 'tcx> NiceRegionError<'a, 'tcx> { .hir() .trait_impls(trait_did) .iter() - .filter_map(|impl_node| { - let impl_did = tcx.hir().local_def_id(*impl_node); + .filter_map(|&impl_did| { match tcx.hir().get_if_local(impl_did.to_def_id()) { Some(Node::Item(Item { kind: ItemKind::Impl(hir::Impl { self_ty, .. }), diff --git a/compiler/rustc_middle/src/hir/map/mod.rs b/compiler/rustc_middle/src/hir/map/mod.rs index 35f7fa0f6d741..178253316f4b6 100644 --- a/compiler/rustc_middle/src/hir/map/mod.rs +++ b/compiler/rustc_middle/src/hir/map/mod.rs @@ -449,7 +449,7 @@ impl<'hir> Map<'hir> { } } - pub fn trait_impls(&self, trait_did: DefId) -> &'hir [HirId] { + pub fn trait_impls(&self, trait_did: DefId) -> &'hir [LocalDefId] { self.tcx.all_local_trait_impls(LOCAL_CRATE).get(&trait_did).map_or(&[], |xs| &xs[..]) } diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs index f0166ec21672b..475f47c65bd25 100644 --- a/compiler/rustc_middle/src/query/mod.rs +++ b/compiler/rustc_middle/src/query/mod.rs @@ -956,7 +956,7 @@ rustc_queries! { /// Passing in any other crate will cause an ICE. /// /// [`LOCAL_CRATE`]: rustc_hir::def_id::LOCAL_CRATE - query all_local_trait_impls(local_crate: CrateNum) -> &'tcx BTreeMap> { + query all_local_trait_impls(local_crate: CrateNum) -> &'tcx BTreeMap> { desc { "local trait impls" } } diff --git a/compiler/rustc_middle/src/ty/trait_def.rs b/compiler/rustc_middle/src/ty/trait_def.rs index f4d7eac0ae2f8..ce17a724e25d3 100644 --- a/compiler/rustc_middle/src/ty/trait_def.rs +++ b/compiler/rustc_middle/src/ty/trait_def.rs @@ -4,9 +4,8 @@ use crate::ty::fast_reject; use crate::ty::fold::TypeFoldable; use crate::ty::{Ty, TyCtxt}; use rustc_hir as hir; -use rustc_hir::def_id::{CrateNum, DefId}; +use rustc_hir::def_id::{CrateNum, DefId, LocalDefId}; use rustc_hir::definitions::DefPathHash; -use rustc_hir::HirId; use rustc_data_structures::fx::FxHashMap; use rustc_data_structures::stable_hasher::{HashStable, StableHasher}; @@ -201,7 +200,7 @@ impl<'tcx> TyCtxt<'tcx> { pub(super) fn all_local_trait_impls<'tcx>( tcx: TyCtxt<'tcx>, krate: CrateNum, -) -> &'tcx BTreeMap> { +) -> &'tcx BTreeMap> { &tcx.hir_crate(krate).trait_impls } @@ -229,8 +228,8 @@ pub(super) fn trait_impls_of_provider(tcx: TyCtxt<'_>, trait_id: DefId) -> Trait } } - for &hir_id in tcx.hir().trait_impls(trait_id) { - let impl_def_id = tcx.hir().local_def_id(hir_id).to_def_id(); + for &impl_def_id in tcx.hir().trait_impls(trait_id) { + let impl_def_id = impl_def_id.to_def_id(); let impl_self_ty = tcx.type_of(impl_def_id); if impl_self_ty.references_error() { diff --git a/compiler/rustc_typeck/src/coherence/builtin.rs b/compiler/rustc_typeck/src/coherence/builtin.rs index 6726b9b4a4b65..5b44cb7eae516 100644 --- a/compiler/rustc_typeck/src/coherence/builtin.rs +++ b/compiler/rustc_typeck/src/coherence/builtin.rs @@ -38,8 +38,7 @@ impl<'tcx> Checker<'tcx> { F: FnMut(TyCtxt<'tcx>, LocalDefId), { if Some(self.trait_def_id) == trait_def_id { - for &impl_id in self.tcx.hir().trait_impls(self.trait_def_id) { - let impl_def_id = self.tcx.hir().local_def_id(impl_id); + for &impl_def_id in self.tcx.hir().trait_impls(self.trait_def_id) { f(self.tcx, impl_def_id); } } diff --git a/compiler/rustc_typeck/src/coherence/mod.rs b/compiler/rustc_typeck/src/coherence/mod.rs index 4294450333ca3..05906817914c6 100644 --- a/compiler/rustc_typeck/src/coherence/mod.rs +++ b/compiler/rustc_typeck/src/coherence/mod.rs @@ -172,8 +172,7 @@ fn coherent_trait(tcx: TyCtxt<'_>, def_id: DefId) { tcx.ensure().specialization_graph_of(def_id); let impls = tcx.hir().trait_impls(def_id); - for &hir_id in impls { - let impl_def_id = tcx.hir().local_def_id(hir_id); + for &impl_def_id in impls { let trait_ref = tcx.impl_trait_ref(impl_def_id).unwrap(); check_impl(tcx, impl_def_id, trait_ref); diff --git a/src/librustdoc/passes/collect_trait_impls.rs b/src/librustdoc/passes/collect_trait_impls.rs index 6f992b3a916ee..0951a9c2c9794 100644 --- a/src/librustdoc/passes/collect_trait_impls.rs +++ b/src/librustdoc/passes/collect_trait_impls.rs @@ -58,8 +58,8 @@ crate fn collect_trait_impls(krate: Crate, cx: &DocContext<'_>) -> Crate { // doesn't work with it anyway, so pull them from the HIR map instead let mut extra_attrs = Vec::new(); for &trait_did in cx.tcx.all_traits(LOCAL_CRATE).iter() { - for &impl_node in cx.tcx.hir().trait_impls(trait_did) { - let impl_did = cx.tcx.hir().local_def_id(impl_node).to_def_id(); + for &impl_did in cx.tcx.hir().trait_impls(trait_did) { + let impl_did = impl_did.to_def_id(); cx.tcx.sess.prof.generic_activity("build_local_trait_impl").run(|| { let mut parent = cx.tcx.parent(impl_did); while let Some(did) = parent { From 91d8e59ccaacf7df2af847037d30871ed0bd90b6 Mon Sep 17 00:00:00 2001 From: Camille GILLOT Date: Mon, 1 Feb 2021 11:32:26 +0100 Subject: [PATCH 14/14] Remove HirItemLike. --- .../rustc_middle/src/hir/map/collector.rs | 32 ++++--------------- 1 file changed, 7 insertions(+), 25 deletions(-) diff --git a/compiler/rustc_middle/src/hir/map/collector.rs b/compiler/rustc_middle/src/hir/map/collector.rs index b9fb3142c633e..a5ffa9c7a54b0 100644 --- a/compiler/rustc_middle/src/hir/map/collector.rs +++ b/compiler/rustc_middle/src/hir/map/collector.rs @@ -55,22 +55,19 @@ fn insert_vec_map(map: &mut IndexVec>, k: K, v: V map[k] = Some(v); } -fn hash( - hcx: &mut StableHashingContext<'_>, - input: impl for<'a> HashStable>, -) -> Fingerprint { - let mut stable_hasher = StableHasher::new(); - input.hash_stable(hcx, &mut stable_hasher); - stable_hasher.finish() -} - fn hash_body( hcx: &mut StableHashingContext<'_>, def_path_hash: DefPathHash, item_like: impl for<'a> HashStable>, hir_body_nodes: &mut Vec<(DefPathHash, Fingerprint)>, ) -> Fingerprint { - let hash = hash(hcx, HirItemLike { item_like: &item_like }); + let hash = { + let mut stable_hasher = StableHasher::new(); + hcx.while_hashing_hir_bodies(true, |hcx| { + item_like.hash_stable(hcx, &mut stable_hasher); + }); + stable_hasher.finish() + }; hir_body_nodes.push((def_path_hash, hash)); hash } @@ -575,18 +572,3 @@ impl<'a, 'hir> Visitor<'hir> for NodeCollector<'a, 'hir> { self.visit_nested_foreign_item(id); } } - -struct HirItemLike { - item_like: T, -} - -impl<'hir, T> HashStable> for HirItemLike -where - T: HashStable>, -{ - fn hash_stable(&self, hcx: &mut StableHashingContext<'hir>, hasher: &mut StableHasher) { - hcx.while_hashing_hir_bodies(true, |hcx| { - self.item_like.hash_stable(hcx, hasher); - }); - } -}