fn visit_trait_item(&mut self, item: &'lcx TraitItem) {
self.lctx.with_hir_id_owner(item.id, |lctx| {
- let id = hir::TraitItemId { node_id: item.id };
let hir_item = lctx.lower_trait_item(item);
+ let id = hir::TraitItemId { hir_id: hir_item.hir_id };
lctx.trait_items.insert(id, hir_item);
lctx.modules.get_mut(&lctx.current_module).unwrap().trait_items.insert(id);
});
fn visit_impl_item(&mut self, item: &'lcx ImplItem) {
self.lctx.with_hir_id_owner(item.id, |lctx| {
- let id = hir::ImplItemId { node_id: item.id };
let hir_item = lctx.lower_impl_item(item);
+ let id = hir::ImplItemId { hir_id: hir_item.hir_id };
lctx.impl_items.insert(id, hir_item);
lctx.modules.get_mut(&lctx.current_module).unwrap().impl_items.insert(id);
});
let target_id = match destination {
Some((id, _)) => {
if let Def::Label(loop_id) = self.expect_full_def(id) {
- Ok(self.lower_node_id(loop_id).node_id)
+ Ok(self.lower_node_id(loop_id).hir_id)
} else {
Err(hir::LoopIdError::UnresolvedLabel)
}
self.loop_scopes
.last()
.cloned()
- .map(|id| Ok(self.lower_node_id(id).node_id))
+ .map(|id| Ok(self.lower_node_id(id).hir_id))
.unwrap_or(Err(hir::LoopIdError::OutsideLoopScope))
.into()
}
trace!("exist ty def index: {:#?}", exist_ty_def_index);
let exist_ty_item = hir::Item {
- id: exist_ty_id.node_id,
hir_id: exist_ty_id.hir_id,
ident: keywords::Invalid.ident(),
attrs: Default::default(),
hir::PathSegment::new(
segment.ident,
- Some(id.node_id),
Some(id.hir_id),
Some(def),
generic_args,
fn lower_variant_data(&mut self, vdata: &VariantData) -> hir::VariantData {
match *vdata {
VariantData::Struct(ref fields, id) => {
- let LoweredNodeId { node_id, hir_id } = self.lower_node_id(id);
+ let LoweredNodeId { node_id: _, hir_id } = self.lower_node_id(id);
hir::VariantData::Struct(
fields
.enumerate()
.map(|f| self.lower_struct_field(f))
.collect(),
- node_id,
hir_id,
)
},
VariantData::Tuple(ref fields, id) => {
- let LoweredNodeId { node_id, hir_id } = self.lower_node_id(id);
+ let LoweredNodeId { node_id: _, hir_id } = self.lower_node_id(id);
hir::VariantData::Tuple(
fields
.enumerate()
.map(|f| self.lower_struct_field(f))
.collect(),
- node_id,
hir_id,
)
},
VariantData::Unit(id) => {
- let LoweredNodeId { node_id, hir_id } = self.lower_node_id(id);
+ let LoweredNodeId { node_id: _, hir_id } = self.lower_node_id(id);
- hir::VariantData::Unit(node_id, hir_id)
+ hir::VariantData::Unit(hir_id)
},
}
}
}
fn lower_struct_field(&mut self, (index, f): (usize, &StructField)) -> hir::StructField {
- let LoweredNodeId { node_id, hir_id } = self.lower_node_id(f.id);
+ let LoweredNodeId { node_id: _, hir_id } = self.lower_node_id(f.id);
hir::StructField {
span: f.span,
- id: node_id,
hir_id,
ident: match f.ident {
Some(ident) => ident,
this.insert_item(
new_id.node_id,
hir::Item {
- id: new_id.node_id,
hir_id: new_id.hir_id,
ident,
attrs: attrs.clone(),
this.insert_item(
new_id,
hir::Item {
- id: new_id,
hir_id: new_hir_id,
ident,
attrs: attrs.clone(),
debug!("renumber_segment_ids(path = {:?})", path);
let mut path = path.clone();
for seg in path.segments.iter_mut() {
- if seg.id.is_some() {
- let next_id = self.next_id();
- seg.id = Some(next_id.node_id);
- seg.hir_id = Some(next_id.hir_id);
+ if seg.hir_id.is_some() {
+ seg.hir_id = Some(self.next_id().hir_id);
}
}
path
TraitItemKind::Macro(..) => unimplemented!(),
};
hir::TraitItemRef {
- id: hir::TraitItemId { node_id: i.id },
+ id: hir::TraitItemId { hir_id: self.lower_node_id(i.id).hir_id },
ident: i.ident,
span: i.span,
defaultness: self.lower_defaultness(Defaultness::Default, has_default),
fn lower_impl_item_ref(&mut self, i: &ImplItem) -> hir::ImplItemRef {
hir::ImplItemRef {
- id: hir::ImplItemId { node_id: i.id },
+ id: hir::ImplItemId { hir_id: self.lower_node_id(i.id).hir_id },
ident: i.ident,
span: i.span,
vis: self.lower_visibility(&i.vis, Some(i.id)),
let node = self.lower_item_kind(i.id, &mut ident, &attrs, &mut vis, &i.node);
- let LoweredNodeId { node_id, hir_id } = self.lower_node_id(i.id);
+ let LoweredNodeId { node_id: _, hir_id } = self.lower_node_id(i.id);
Some(hir::Item {
- id: node_id,
hir_id,
ident,
attrs,
let LoweredNodeId { node_id, hir_id } = self.lower_node_id(i.id);
let def_id = self.resolver.definitions().local_def_id(node_id);
hir::ForeignItem {
- id: node_id,
hir_id,
ident: i.ident,
attrs: self.lower_attrs(&i.attrs),
Some(Def::Local(id)) => id,
_ => p.id,
};
- let hir_id = self.lower_node_id(canonical_id).hir_id;
+
hir::PatKind::Binding(
self.lower_binding_mode(binding_mode),
- canonical_id,
- hir_id,
+ self.lower_node_id(canonical_id).hir_id,
ident,
sub.as_ref().map(|x| self.lower_pat(x)),
)
let fs = fields
.iter()
.map(|f| {
- let LoweredNodeId { node_id, hir_id } = self.next_id();
+ let LoweredNodeId { node_id: _, hir_id } = self.next_id();
Spanned {
span: f.span,
node: hir::FieldPat {
- id: node_id,
hir_id,
ident: f.node.ident,
pat: self.lower_pat(&f.node.pat),
PatKind::Mac(_) => panic!("Shouldn't exist here"),
};
- let LoweredNodeId { node_id, hir_id } = self.lower_node_id(p.id);
+ let LoweredNodeId { node_id: _, hir_id } = self.lower_node_id(p.id);
P(hir::Pat {
- id: node_id,
hir_id,
node,
span: p.span,
let iter = self.str_to_ident("iter");
let next_ident = self.str_to_ident("__next");
- let next_pat = self.pat_ident_binding_mode(
+ let (next_pat, next_pat_nid) = self.pat_ident_binding_mode(
desugared_span,
next_ident,
hir::BindingAnnotation::Mutable,
// `::std::option::Option::Some(val) => next = val`
let pat_arm = {
let val_ident = self.str_to_ident("val");
- let val_pat = self.pat_ident(pat.span, val_ident);
- let val_expr = P(self.expr_ident(pat.span, val_ident, val_pat.id));
- let next_expr = P(self.expr_ident(pat.span, next_ident, next_pat.id));
+ let (val_pat, val_pat_nid) = self.pat_ident(pat.span, val_ident);
+ let val_expr = P(self.expr_ident(pat.span, val_ident, val_pat_nid));
+ let next_expr = P(self.expr_ident(pat.span, next_ident, next_pat_nid));
let assign = P(self.expr(
pat.span,
hir::ExprKind::Assign(next_expr, val_expr),
};
// `mut iter`
- let iter_pat = self.pat_ident_binding_mode(
+ let (iter_pat, iter_pat_nid) = self.pat_ident_binding_mode(
desugared_span,
iter,
hir::BindingAnnotation::Mutable
// `match ::std::iter::Iterator::next(&mut iter) { ... }`
let match_expr = {
- let iter = P(self.expr_ident(head_sp, iter, iter_pat.id));
+ let iter = P(self.expr_ident(head_sp, iter, iter_pat_nid));
let ref_mut_iter = self.expr_mut_addr_of(head_sp, iter);
let next_path = &["iter", "Iterator", "next"];
let next_path = P(self.expr_std_path(head_sp, next_path, None, ThinVec::new()));
span: head_sp,
};
- let next_expr = P(self.expr_ident(head_sp, next_ident, next_pat.id));
+ let next_expr = P(self.expr_ident(head_sp, next_ident, next_pat_nid));
// `let mut __next`
let next_let = self.stmt_let_pat(
// `Ok(val) => #[allow(unreachable_code)] val,`
let ok_arm = {
let val_ident = self.str_to_ident("val");
- let val_pat = self.pat_ident(e.span, val_ident);
+ let (val_pat, val_pat_nid) = self.pat_ident(e.span, val_ident);
let val_expr = P(self.expr_ident_with_attrs(
e.span,
val_ident,
- val_pat.id,
+ val_pat_nid,
ThinVec::from(attrs.clone()),
));
let ok_pat = self.pat_ok(e.span, val_pat);
// return Try::from_error(From::from(err)),`
let err_arm = {
let err_ident = self.str_to_ident("err");
- let err_local = self.pat_ident(e.span, err_ident);
+ let (err_local, err_local_nid) = self.pat_ident(e.span, err_ident);
let from_expr = {
let path = &["convert", "From", "from"];
let from = P(self.expr_std_path(
e.span, path, None, ThinVec::new()));
- let err_expr = self.expr_ident(e.span, err_ident, err_local.id);
+ let err_expr = self.expr_ident(e.span, err_ident, err_local_nid);
self.expr_call(e.span, from, hir_vec![err_expr])
};
let thin_attrs = ThinVec::from(attrs);
let catch_scope = self.catch_scopes.last().map(|x| *x);
let ret_expr = if let Some(catch_node) = catch_scope {
+ let target_id = Ok(self.lower_node_id(catch_node).hir_id);
P(self.expr(
e.span,
hir::ExprKind::Break(
hir::Destination {
label: None,
- target_id: Ok(catch_node),
+ target_id,
},
Some(from_err_expr),
),
ident: Ident,
ex: P<hir::Expr>,
) -> (hir::Stmt, NodeId) {
- let pat = if mutbl {
+ let (pat, pat_nid) = if mutbl {
self.pat_ident_binding_mode(sp, ident, hir::BindingAnnotation::Mutable)
} else {
self.pat_ident(sp, ident)
};
- let pat_id = pat.id;
+
(
self.stmt_let_pat(sp, Some(ex), pat, hir::LocalSource::Normal),
- pat_id,
+ pat_nid,
)
}
self.pat(span, pt)
}
- fn pat_ident(&mut self, span: Span, ident: Ident) -> P<hir::Pat> {
+ fn pat_ident(&mut self, span: Span, ident: Ident) -> (P<hir::Pat>, NodeId) {
self.pat_ident_binding_mode(span, ident, hir::BindingAnnotation::Unannotated)
}
span: Span,
ident: Ident,
bm: hir::BindingAnnotation,
- ) -> P<hir::Pat> {
+ ) -> (P<hir::Pat>, NodeId) {
let LoweredNodeId { node_id, hir_id } = self.next_id();
- P(hir::Pat {
- id: node_id,
- hir_id,
- node: hir::PatKind::Binding(bm, node_id, hir_id, ident.with_span_pos(span), None),
- span,
- })
+ (
+ P(hir::Pat {
+ hir_id,
+ node: hir::PatKind::Binding(bm, hir_id, ident.with_span_pos(span), None),
+ span,
+ }),
+ node_id
+ )
}
fn pat_wild(&mut self, span: Span) -> P<hir::Pat> {
}
fn pat(&mut self, span: Span, pat: hir::PatKind) -> P<hir::Pat> {
- let LoweredNodeId { node_id, hir_id } = self.next_id();
+ let LoweredNodeId { node_id: _, hir_id } = self.next_id();
P(hir::Pat {
- id: node_id,
hir_id,
node: pat,
span,
for seg in path.segments.iter_mut() {
- if let Some(id) = seg.id {
- seg.id = Some(self.lower_node_id(id).node_id);
+ if seg.hir_id.is_some() {
+ seg.hir_id = Some(self.next_id().hir_id);
}
}
path