bjoernager/rust
bjoernager/rust
1
Fork 0
Code Issues Pull requests Activity

Do not modify the resolver outputs.

Browse source
This commit is contained in:
Camille GILLOT 2021-07-18 20:09:20 +02:00
parent 603746a35e
commit b676edd641
4 changed files with 83 additions and 75 deletions
Download patch file Download diff file Expand all files Collapse all files

2
compiler/rustc_ast_lowering/src/asm.rs
View file

@ -242,7 +242,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
// Wrap the expression in an AnonConst.
let parent_def_id = self.current_hir_id_owner;
let node_id = self.resolver.next_node_id();
let node_id = self.next_node_id();
self.create_def(
parent_def_id,
node_id,

4
compiler/rustc_ast_lowering/src/expr.rs
View file

@ -355,7 +355,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
for (idx, arg) in args.into_iter().enumerate() {
if legacy_args_idx.contains(&idx) {
let parent_def_id = self.current_hir_id_owner;
let node_id = self.resolver.next_node_id();
let node_id = self.next_node_id();
// Add a definition for the in-band const def.
self.create_def(
@ -724,7 +724,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
};
// `::std::task::Poll::Ready(result) => break result`
let loop_node_id = self.resolver.next_node_id();
let loop_node_id = self.next_node_id();
let loop_hir_id = self.lower_node_id(loop_node_id);
let ready_arm = {
let x_ident = Ident::with_dummy_span(sym::result);

36
compiler/rustc_ast_lowering/src/item.rs
View file

@ -62,6 +62,7 @@ impl<'a, 'hir> ItemLowerer<'a, 'hir> {
owner: NodeId,
f: impl FnOnce(&mut LoweringContext<'_, 'hir>) -> hir::OwnerNode<'hir>,
) {
let next_node_id = self.resolver.next_node_id;
let mut lctx = LoweringContext {
// Pseudo-globals.
sess: &self.sess,
@ -79,6 +80,8 @@ impl<'a, 'hir> ItemLowerer<'a, 'hir> {
node_id_to_local_id: Default::default(),
local_id_to_def_id: SortedMap::new(),
trait_map: Default::default(),
local_node_id_to_def_id: FxHashMap::default(),
next_node_id,
// Lowering state.
catch_scope: None,
@ -126,8 +129,7 @@ impl<'a, 'hir> ItemLowerer<'a, 'hir> {
#[instrument(level = "debug", skip(self, c))]
fn lower_crate(&mut self, c: &Crate) {
debug_assert_eq!(self.resolver.local_def_id(CRATE_NODE_ID), CRATE_DEF_ID);
debug_assert_eq!(self.resolver.node_id_to_def_id[&CRATE_NODE_ID], CRATE_DEF_ID);
self.with_lctx(CRATE_NODE_ID, |lctx| {
let module = lctx.lower_mod(&c.items, &c.spans);
lctx.lower_attrs(hir::CRATE_HIR_ID, &c.attrs);
@ -141,7 +143,7 @@ impl<'a, 'hir> ItemLowerer<'a, 'hir> {
}
fn lower_assoc_item(&mut self, item: &AssocItem, ctxt: AssocCtxt) {
let def_id = self.resolver.local_def_id(item.id);
let def_id = self.resolver.node_id_to_def_id[&item.id];
let parent_id = {
let parent = self.definitions.def_key(def_id).parent;
@ -185,7 +187,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
}
pub(super) fn lower_item_ref(&mut self, i: &Item) -> SmallVec<[hir::ItemId; 1]> {
let mut node_ids = smallvec![hir::ItemId { def_id: self.resolver.local_def_id(i.id) }];
let mut node_ids = smallvec![hir::ItemId { def_id: self.local_def_id(i.id) }];
if let ItemKind::Use(ref use_tree) = &i.kind {
self.lower_item_id_use_tree(use_tree, i.id, &mut node_ids);
}
@ -201,7 +203,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
match tree.kind {
UseTreeKind::Nested(ref nested_vec) => {
for &(ref nested, id) in nested_vec {
vec.push(hir::ItemId { def_id: self.resolver.local_def_id(id) });
vec.push(hir::ItemId { def_id: self.local_def_id(id) });
self.lower_item_id_use_tree(nested, id, vec);
}
}
@ -210,7 +212,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
for (_, &id) in
iter::zip(self.expect_full_res_from_use(base_id).skip(1), &[id1, id2])
{
vec.push(hir::ItemId { def_id: self.resolver.local_def_id(id) });
vec.push(hir::ItemId { def_id: self.local_def_id(id) });
}
}
}
@ -475,7 +477,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
}
ItemKind::MacroDef(MacroDef { ref body, macro_rules }) => {
let body = P(self.lower_mac_args(body));
let macro_kind = self.resolver.decl_macro_kind(self.resolver.local_def_id(id));
let macro_kind = self.resolver.decl_macro_kind(self.local_def_id(id));
hir::ItemKind::Macro(ast::MacroDef { body, macro_rules }, macro_kind)
}
ItemKind::MacCall(..) => {
@ -535,7 +537,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
// Essentially a single `use` which imports two names is desugared into
// two imports.
for new_node_id in [id1, id2] {
let new_id = self.resolver.local_def_id(new_node_id);
let new_id = self.local_def_id(new_node_id);
let Some(res) = resolutions.next() else {
// Associate an HirId to both ids even if there is no resolution.
let _old = self.children.insert(
@ -548,7 +550,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
let ident = *ident;
let mut path = path.clone();
for seg in &mut path.segments {
seg.id = self.resolver.next_node_id();
seg.id = self.next_node_id();
}
let span = path.span;
@ -611,13 +613,13 @@ impl<'hir> LoweringContext<'_, 'hir> {
// Add all the nested `PathListItem`s to the HIR.
for &(ref use_tree, id) in trees {
let new_hir_id = self.resolver.local_def_id(id);
let new_hir_id = self.local_def_id(id);
let mut prefix = prefix.clone();
// Give the segments new node-ids since they are being cloned.
for seg in &mut prefix.segments {
seg.id = self.resolver.next_node_id();
seg.id = self.next_node_id();
}
// Each `use` import is an item and thus are owners of the
@ -691,7 +693,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
fn lower_foreign_item_ref(&mut self, i: &ForeignItem) -> hir::ForeignItemRef {
hir::ForeignItemRef {
id: hir::ForeignItemId { def_id: self.resolver.local_def_id(i.id) },
id: hir::ForeignItemId { def_id: self.local_def_id(i.id) },
ident: self.lower_ident(i.ident),
span: self.lower_span(i.span),
}
@ -847,7 +849,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
}
AssocItemKind::MacCall(..) => unimplemented!(),
};
let id = hir::TraitItemId { def_id: self.resolver.local_def_id(i.id) };
let id = hir::TraitItemId { def_id: self.local_def_id(i.id) };
let defaultness = hir::Defaultness::Default { has_value: has_default };
hir::TraitItemRef {
id,
@ -927,7 +929,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
let has_value = true;
let (defaultness, _) = self.lower_defaultness(i.kind.defaultness(), has_value);
hir::ImplItemRef {
id: hir::ImplItemId { def_id: self.resolver.local_def_id(i.id) },
id: hir::ImplItemId { def_id: self.local_def_id(i.id) },
ident: self.lower_ident(i.ident),
span: self.lower_span(i.span),
defaultness,
@ -1339,7 +1341,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
generics
.params
.iter()
.any(|p| def_id == self.resolver.local_def_id(p.id).to_def_id())
.any(|p| def_id == self.local_def_id(p.id).to_def_id())
}
// Either the `bounded_ty` is not a plain type parameter, or
// it's not found in the generic type parameters list.
@ -1443,7 +1445,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
match kind {
GenericParamKind::Const { .. } => None,
GenericParamKind::Type { .. } => {
let def_id = self.resolver.local_def_id(id).to_def_id();
let def_id = self.local_def_id(id).to_def_id();
let ty_path = self.arena.alloc(hir::Path {
span: param_span,
res: Res::Def(DefKind::TyParam, def_id),
@ -1466,7 +1468,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
let res = self.resolver.get_lifetime_res(id).unwrap_or_else(|| {
panic!("Missing resolution for lifetime {:?} at {:?}", id, ident.span)
});
let lt_id = self.resolver.next_node_id();
let lt_id = self.next_node_id();
let lifetime = self.new_named_lifetime_with_res(lt_id, ident_span, ident, res);
Some(hir::WherePredicate::RegionPredicate(hir::WhereRegionPredicate {
lifetime,

116
compiler/rustc_ast_lowering/src/lib.rs
View file

@ -133,6 +133,10 @@ struct LoweringContext<'a, 'hir: 'a> {
/// NodeIds that are lowered inside the current HIR owner.
node_id_to_local_id: FxHashMap<NodeId, hir::ItemLocalId>,
// The next_node_id is reset for each item.
next_node_id: ast::NodeId,
local_node_id_to_def_id: FxHashMap<ast::NodeId, LocalDefId>,
allow_try_trait: Option<Lrc<[Symbol]>>,
allow_gen_future: Option<Lrc<[Symbol]>>,
allow_into_future: Option<Lrc<[Symbol]>>,
@ -167,9 +171,6 @@ trait ResolverAstLoweringExt {
fn get_label_res(&self, id: NodeId) -> Option<NodeId>;
fn get_lifetime_res(&self, id: NodeId) -> Option<LifetimeRes>;
fn take_extra_lifetime_params(&mut self, id: NodeId) -> Vec<(Ident, NodeId, LifetimeRes)>;
fn next_node_id(&mut self) -> NodeId;
fn opt_local_def_id(&self, node: NodeId) -> Option<LocalDefId>;
fn local_def_id(&self, node: NodeId) -> LocalDefId;
fn decl_macro_kind(&self, def_id: LocalDefId) -> MacroKind;
}
@ -229,24 +230,6 @@ impl ResolverAstLoweringExt for ResolverOutputs {
self.extra_lifetime_params_map.remove(&id).unwrap_or_default()
}
fn next_node_id(&mut self) -> NodeId {
let next = self
.next_node_id
.as_usize()
.checked_add(1)
.expect("input too large; ran out of NodeIds");
self.next_node_id = NodeId::from_usize(next);
self.next_node_id
}
fn opt_local_def_id(&self, node: NodeId) -> Option<LocalDefId> {
self.node_id_to_def_id.get(&node).copied()
}
fn local_def_id(&self, node: NodeId) -> LocalDefId {
self.opt_local_def_id(node).unwrap_or_else(|| panic!("no entry for node id: `{:?}`", node))
}
fn decl_macro_kind(&self, def_id: LocalDefId) -> MacroKind {
self.builtin_macro_kinds.get(&def_id).copied().unwrap_or(MacroKind::Bang)
}
@ -359,17 +342,17 @@ enum AstOwner<'a> {
}
fn index_crate<'a>(
resolver: &ResolverOutputs,
node_id_to_def_id: &FxHashMap<NodeId, LocalDefId>,
krate: &'a Crate,
) -> IndexVec<LocalDefId, AstOwner<'a>> {
let mut indexer = Indexer { resolver, index: IndexVec::new() };
let mut indexer = Indexer { node_id_to_def_id, index: IndexVec::new() };
indexer.index.ensure_contains_elem(CRATE_DEF_ID, || AstOwner::NonOwner);
indexer.index[CRATE_DEF_ID] = AstOwner::Crate(krate);
visit::walk_crate(&mut indexer, krate);
return indexer.index;
struct Indexer<'s, 'a> {
resolver: &'s ResolverOutputs,
node_id_to_def_id: &'s FxHashMap<NodeId, LocalDefId>,
index: IndexVec<LocalDefId, AstOwner<'a>>,
}
@ -380,21 +363,21 @@ fn index_crate<'a>(
}
fn visit_item(&mut self, item: &'a ast::Item) {
let def_id = self.resolver.local_def_id(item.id);
let def_id = self.node_id_to_def_id[&item.id];
self.index.ensure_contains_elem(def_id, || AstOwner::NonOwner);
self.index[def_id] = AstOwner::Item(item);
visit::walk_item(self, item)
}
fn visit_assoc_item(&mut self, item: &'a ast::AssocItem, ctxt: visit::AssocCtxt) {
let def_id = self.resolver.local_def_id(item.id);
let def_id = self.node_id_to_def_id[&item.id];
self.index.ensure_contains_elem(def_id, || AstOwner::NonOwner);
self.index[def_id] = AstOwner::AssocItem(item, ctxt);
visit::walk_assoc_item(self, item, ctxt);
}
fn visit_foreign_item(&mut self, item: &'a ast::ForeignItem) {
let def_id = self.resolver.local_def_id(item.id);
let def_id = self.node_id_to_def_id[&item.id];
self.index.ensure_contains_elem(def_id, || AstOwner::NonOwner);
self.index[def_id] = AstOwner::ForeignItem(item);
visit::walk_foreign_item(self, item);
@ -436,7 +419,7 @@ pub fn lower_crate<'hir>(
) -> &'hir hir::Crate<'hir> {
let _prof_timer = sess.prof.verbose_generic_activity("hir_lowering");
let ast_index = index_crate(resolver, krate);
let ast_index = index_crate(&resolver.node_id_to_def_id, krate);
let mut owners =
IndexVec::from_fn_n(|_| hir::MaybeOwner::Phantom, definitions.def_index_count());
@ -488,11 +471,11 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
span: Span,
) -> LocalDefId {
assert!(
!self.resolver.node_id_to_def_id.contains_key(&node_id),
self.opt_local_def_id(node_id).is_none(),
"adding a def'n for node-id {:?} and data {:?} but a previous def'n exists: {:?}",
node_id,
data,
self.definitions.def_key(self.resolver.node_id_to_def_id[&node_id]),
self.definitions.def_key(self.local_def_id(node_id)),
);
let def_id = self.definitions.create_def(parent, data, expn_id, span);
@ -502,20 +485,41 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
// we don't need a mapping from `NodeId` to `LocalDefId`.
if node_id != ast::DUMMY_NODE_ID {
debug!("create_def: def_id_to_node_id[{:?}] <-> {:?}", def_id, node_id);
self.resolver.node_id_to_def_id.insert(node_id, def_id);
self.local_node_id_to_def_id.insert(node_id, def_id);
}
assert_eq!(self.resolver.def_id_to_node_id.push(node_id), def_id);
def_id
}
fn next_node_id(&mut self) -> NodeId {
let next = self
.next_node_id
.as_usize()
.checked_add(1)
.expect("input too large; ran out of NodeIds");
self.next_node_id = NodeId::from_usize(next);
self.next_node_id
}
fn opt_local_def_id(&self, node: NodeId) -> Option<LocalDefId> {
if node <= self.resolver.next_node_id {
self.resolver.node_id_to_def_id.get(&node).copied()
} else {
self.local_node_id_to_def_id.get(&node).copied()
}
}
fn local_def_id(&self, node: NodeId) -> LocalDefId {
self.opt_local_def_id(node).unwrap_or_else(|| panic!("no entry for node id: `{:?}`", node))
}
#[instrument(level = "debug", skip(self, f))]
fn with_hir_id_owner(
&mut self,
owner: NodeId,
f: impl FnOnce(&mut Self) -> hir::OwnerNode<'hir>,
) {
let def_id = self.resolver.local_def_id(owner);
let def_id = self.local_def_id(owner);
let current_attrs = std::mem::take(&mut self.attrs);
let current_bodies = std::mem::take(&mut self.bodies);
@ -527,6 +531,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
std::mem::replace(&mut self.item_local_id_counter, hir::ItemLocalId::new(1));
let current_impl_trait_defs = std::mem::take(&mut self.impl_trait_defs);
let current_impl_trait_bounds = std::mem::take(&mut self.impl_trait_bounds);
// Do not reset `next_node_id` and `node_id_to_def_id` as we want to refer to the
// subdefinitions' nodes.
// Always allocate the first `HirId` for the owner itself.
let _old = self.node_id_to_local_id.insert(owner, hir::ItemLocalId::new(0));
@ -633,7 +639,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
self.item_local_id_counter.increment_by(1);
assert_ne!(local_id, hir::ItemLocalId::new(0));
if let Some(def_id) = self.resolver.opt_local_def_id(ast_node_id) {
if let Some(def_id) = self.opt_local_def_id(ast_node_id) {
// Do not override a `MaybeOwner::Owner` that may already here.
self.children.entry(def_id).or_insert(hir::MaybeOwner::NonOwner(hir_id));
self.local_id_to_def_id.insert(local_id, def_id);
@ -649,7 +655,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
}
fn next_id(&mut self) -> hir::HirId {
let node_id = self.resolver.next_node_id();
let node_id = self.next_node_id();
self.lower_node_id(node_id)
}
@ -991,7 +997,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
// constructing the HIR for `impl bounds...` and then lowering that.
let parent_def_id = self.current_hir_id_owner;
let impl_trait_node_id = self.resolver.next_node_id();
let impl_trait_node_id = self.next_node_id();
self.create_def(
parent_def_id,
impl_trait_node_id,
@ -1001,7 +1007,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
);
self.with_dyn_type_scope(false, |this| {
let node_id = this.resolver.next_node_id();
let node_id = this.next_node_id();
let ty = this.lower_ty(
&Ty {
id: node_id,
@ -1101,7 +1107,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
// Construct an AnonConst where the expr is the "ty"'s path.
let parent_def_id = self.current_hir_id_owner;
let node_id = self.resolver.next_node_id();
let node_id = self.next_node_id();
// Add a definition for the in-band const def.
self.create_def(
@ -1180,7 +1186,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
debug_assert_eq!(start.plus(1), end);
start
} else {
self.resolver.next_node_id()
self.next_node_id()
};
let span = self.sess.source_map().next_point(t.span.shrink_to_lo());
Lifetime { ident: Ident::new(kw::UnderscoreLifetime, span), id }
@ -1323,7 +1329,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
// frequently opened issues show.
let opaque_ty_span = self.mark_span_with_reason(DesugaringKind::OpaqueTy, span, None);
let opaque_ty_def_id = self.resolver.local_def_id(opaque_ty_node_id);
let opaque_ty_def_id = self.local_def_id(opaque_ty_node_id);
let mut collected_lifetimes = FxHashMap::default();
self.with_hir_id_owner(opaque_ty_node_id, |lctx| {
@ -1341,7 +1347,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
let lifetime_defs = lctx.arena.alloc_from_iter(collected_lifetimes.iter().map(
|(_, &(span, p_id, p_name, _))| {
let hir_id = lctx.lower_node_id(p_id);
debug_assert_ne!(lctx.resolver.opt_local_def_id(p_id), None);
debug_assert_ne!(lctx.opt_local_def_id(p_id), None);
let kind = if p_name.ident().name == kw::UnderscoreLifetime {
hir::LifetimeParamKind::Elided
@ -1380,7 +1386,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
let lifetimes = self.arena.alloc_from_iter(collected_lifetimes.into_iter().map(
|(_, (span, _, p_name, res))| {
let id = self.resolver.next_node_id();
let id = self.next_node_id();
let ident = Ident::new(p_name.ident().name, span);
let l = self.new_named_lifetime_with_res(id, span, ident, res);
hir::GenericArg::Lifetime(l)
@ -1489,7 +1495,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
FnRetTy::Ty(ref ty) => {
let context = match fn_node_id {
Some(fn_node_id) if kind.impl_trait_return_allowed() => {
let fn_def_id = self.resolver.local_def_id(fn_node_id);
let fn_def_id = self.local_def_id(fn_node_id);
ImplTraitContext::ReturnPositionOpaqueTy {
origin: hir::OpaqueTyOrigin::FnReturn(fn_def_id),
}
@ -1563,8 +1569,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
let opaque_ty_span = self.mark_span_with_reason(DesugaringKind::Async, span, None);
let opaque_ty_def_id = self.resolver.local_def_id(opaque_ty_node_id);
let fn_def_id = self.resolver.local_def_id(fn_node_id);
let opaque_ty_def_id = self.local_def_id(opaque_ty_node_id);
let fn_def_id = self.local_def_id(fn_node_id);
// When we create the opaque type for this async fn, it is going to have
// to capture all the lifetimes involved in the signature (including in the
@ -1614,8 +1620,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
debug!(?extra_lifetime_params);
for (ident, outer_node_id, outer_res) in extra_lifetime_params {
let Ident { name, span } = ident;
let outer_def_id = self.resolver.local_def_id(outer_node_id);
let inner_node_id = self.resolver.next_node_id();
let outer_def_id = self.local_def_id(outer_node_id);
let inner_node_id = self.next_node_id();
// Add a definition for the in scope lifetime def.
self.create_def(
@ -1665,7 +1671,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
let generic_params =
this.arena.alloc_from_iter(captures.iter().map(|(_, &(span, p_id, p_name, _))| {
let hir_id = this.lower_node_id(p_id);
debug_assert_ne!(this.resolver.opt_local_def_id(p_id), None);
debug_assert_ne!(this.opt_local_def_id(p_id), None);
let kind = if p_name.ident().name == kw::UnderscoreLifetime {
hir::LifetimeParamKind::Elided
@ -1717,7 +1723,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
// generate `'_`.
let generic_args =
self.arena.alloc_from_iter(captures.into_iter().map(|(_, (span, _, p_name, res))| {
let id = self.resolver.next_node_id();
let id = self.next_node_id();
let ident = Ident::new(p_name.ident().name, span);
let l = self.new_named_lifetime_with_res(id, span, ident, res);
hir::GenericArg::Lifetime(l)
@ -1811,9 +1817,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
if let Some(mut captured_lifetimes) = self.captured_lifetimes.take() {
if !captured_lifetimes.binders_to_ignore.contains(&binder) {
match captured_lifetimes.captures.entry(param) {
Entry::Occupied(o) => param = self.resolver.local_def_id(o.get().1),
Entry::Occupied(o) => param = self.local_def_id(o.get().1),
Entry::Vacant(v) => {
let p_id = self.resolver.next_node_id();
let p_id = self.next_node_id();
let p_def_id = self.create_def(
captured_lifetimes.parent_def_id,
p_id,
@ -1837,9 +1843,9 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
if let Some(mut captured_lifetimes) = self.captured_lifetimes.take() {
if !captured_lifetimes.binders_to_ignore.contains(&binder) {
match captured_lifetimes.captures.entry(param) {
Entry::Occupied(o) => param = self.resolver.local_def_id(o.get().1),
Entry::Occupied(o) => param = self.local_def_id(o.get().1),
Entry::Vacant(v) => {
let p_id = self.resolver.next_node_id();
let p_id = self.next_node_id();
let p_def_id = self.create_def(
captured_lifetimes.parent_def_id,
p_id,
@ -1862,7 +1868,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
let mut l_name = None;
if let Some(mut captured_lifetimes) = self.captured_lifetimes.take() {
if !captured_lifetimes.binders_to_ignore.contains(&binder) {
let p_id = self.resolver.next_node_id();
let p_id = self.next_node_id();
let p_def_id = self.create_def(
captured_lifetimes.parent_def_id,
p_id,
@ -2011,7 +2017,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
bounds: &[GenericBound],
) -> (hir::GenericParam<'hir>, Option<hir::WherePredicate<'hir>>, hir::TyKind<'hir>) {
// Add a definition for the in-band `Param`.
let def_id = self.resolver.local_def_id(node_id);
let def_id = self.local_def_id(node_id);
let hir_bounds = self.lower_param_bounds(bounds, ImplTraitContext::Universal);
// Set the name to `impl Bound1 + Bound2`.