args: I) -> CFGIndex {
let func_or_rcvr_exit = self.expr(func_or_rcvr, pred);
let ret = self.straightline(call_expr, func_or_rcvr_exit, args);
- let m = self.tcx.hir().get_module_parent(call_expr.id);
+ let m = self.tcx.hir().get_module_parent_by_hir_id(call_expr.hir_id);
if self.tcx.is_ty_uninhabited_from(m, self.tables.expr_ty(call_expr)) {
self.add_unreachable_node()
} else {
let closure_hir_id = self.lower_node_id(closure_node_id).hir_id;
let decl = self.lower_fn_decl(&decl, None, /* impl trait allowed */ false, None);
let generator = hir::Expr {
- id: closure_node_id,
hir_id: closure_hir_id,
node: hir::ExprKind::Closure(capture_clause, decl, body_id, span,
Some(hir::GeneratorMovability::Static)),
let mut block = this.lower_block(body, true).into_inner();
let tail = block.expr.take().map_or_else(
|| {
- let LoweredNodeId { node_id, hir_id } = this.next_id();
+ let LoweredNodeId { node_id: _, hir_id } = this.next_id();
let span = this.sess.source_map().end_point(unstable_span);
hir::Expr {
- id: node_id,
span,
node: hir::ExprKind::Tup(hir_vec![]),
attrs: ThinVec::new(),
let struct_path = self.std_path(e.span, &struct_path, None, is_unit);
let struct_path = hir::QPath::Resolved(None, P(struct_path));
- let LoweredNodeId { node_id, hir_id } = self.lower_node_id(e.id);
+ let LoweredNodeId { node_id: _, hir_id } = self.lower_node_id(e.id);
return hir::Expr {
- id: node_id,
hir_id,
node: if is_unit {
hir::ExprKind::Path(struct_path)
self.lower_label(opt_label),
hir::LoopSource::ForLoop,
);
- let LoweredNodeId { node_id, hir_id } = self.lower_node_id(e.id);
+ let LoweredNodeId { node_id: _, hir_id } = self.lower_node_id(e.id);
let loop_expr = P(hir::Expr {
- id: node_id,
hir_id,
node: loop_expr,
span: e.span,
ExprKind::Mac(_) => panic!("Shouldn't exist here"),
};
- let LoweredNodeId { node_id, hir_id } = self.lower_node_id(e.id);
+ let LoweredNodeId { node_id: _, hir_id } = self.lower_node_id(e.id);
hir::Expr {
- id: node_id,
hir_id,
node: kind,
span: e.span,
}
fn expr(&mut self, span: Span, node: hir::ExprKind, attrs: ThinVec<Attribute>) -> hir::Expr {
- let LoweredNodeId { node_id, hir_id } = self.next_id();
+ let LoweredNodeId { node_id: _, hir_id } = self.next_id();
hir::Expr {
- id: node_id,
hir_id,
node,
span,
}
impl<'a> Code<'a> {
- pub fn id(&self) -> NodeId {
+ pub fn id(&self) -> ast::HirId {
match *self {
Code::FnLike(node) => node.id(),
- Code::Expr(block) => block.id,
+ Code::Expr(block) => block.hir_id,
}
}
vis: &'a ast::Visibility,
generics: &'a ast::Generics,
body: ast::BodyId,
- id: NodeId,
+ id: ast::HirId,
span: Span,
attrs: &'a [Attribute],
}
struct ClosureParts<'a> {
decl: &'a FnDecl,
body: ast::BodyId,
- id: NodeId,
+ id: ast::HirId,
span: Span,
attrs: &'a [Attribute],
}
impl<'a> ClosureParts<'a> {
- fn new(d: &'a FnDecl, b: ast::BodyId, id: NodeId, s: Span, attrs: &'a [Attribute]) -> Self {
+ fn new(d: &'a FnDecl, b: ast::BodyId, id: ast::HirId, s: Span, attrs: &'a [Attribute]) -> Self {
ClosureParts {
decl: d,
body: b,
|c: ClosureParts<'_>| c.span)
}
- pub fn id(self) -> NodeId {
+ pub fn id(self) -> ast::HirId {
self.handle(|i: ItemFnParts<'_>| i.id,
|id, _, _: &'a ast::MethodSig, _, _, _, _| id,
|c: ClosureParts<'_>| c.id)
fn handle<A, I, M, C>(self, item_fn: I, method: M, closure: C) -> A where
I: FnOnce(ItemFnParts<'a>) -> A,
- M: FnOnce(NodeId,
+ M: FnOnce(ast::HirId,
Ident,
&'a ast::MethodSig,
Option<&'a ast::Visibility>,
map::Node::Item(i) => match i.node {
ast::ItemKind::Fn(ref decl, header, ref generics, block) =>
item_fn(ItemFnParts {
- id: i.id,
+ id: i.hir_id,
ident: i.ident,
decl: &decl,
body: block,
},
map::Node::TraitItem(ti) => match ti.node {
ast::TraitItemKind::Method(ref sig, ast::TraitMethod::Provided(body)) => {
- method(ti.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"),
},
map::Node::ImplItem(ii) => {
match ii.node {
ast::ImplItemKind::Method(ref sig, body) => {
- method(ii.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")
}
},
map::Node::Expr(e) => match e.node {
ast::ExprKind::Closure(_, ref decl, block, _fn_decl_span, _gen) =>
- closure(ClosureParts::new(&decl, block, e.id, e.span, &e.attrs)),
+ closure(ClosureParts::new(&decl, block, e.hir_id, e.span, &e.attrs)),
_ => bug!("expr FnLikeNode that is not fn-like"),
},
_ => bug!("other FnLikeNode that is not fn-like"),
/// false
/// }
/// ```
- pub fn get_return_block(&self, id: NodeId) -> Option<NodeId> {
+ pub fn get_return_block(&self, id: HirId) -> Option<HirId> {
let match_fn = |node: &Node<'_>| {
match *node {
Node::Item(_) |
}
};
- self.walk_parent_nodes(id, match_fn, match_non_returning_block).ok()
+ let node_id = self.hir_to_node_id(id);
+ self.walk_parent_nodes(node_id, match_fn, match_non_returning_block)
+ .ok()
+ .map(|return_node_id| self.node_to_hir_id(return_node_id))
}
/// Retrieves the `NodeId` for `id`'s parent item, or `id` itself if no
/// An expression
#[derive(Clone, RustcEncodable, RustcDecodable)]
pub struct Expr {
- pub id: NodeId,
pub span: Span,
pub node: ExprKind,
pub attrs: ThinVec<Attribute>,
impl fmt::Debug for Expr {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- write!(f, "expr({}: {})", self.id,
+ write!(f, "expr({}: {})", self.hir_id,
print::to_string(print::NO_ANN, |s| s.print_expr(self)))
}
}
hasher: &mut StableHasher<W>) {
hcx.while_hashing_hir_bodies(true, |hcx| {
let hir::Expr {
- id: _,
hir_id: _,
ref span,
ref node,
};
let krate = tcx.hir().krate();
- builder.with_lint_attrs(ast::CRATE_NODE_ID, &krate.attrs, |builder| {
+ builder.with_lint_attrs(hir::CRATE_HIR_ID, &krate.attrs, |builder| {
intravisit::walk_crate(builder, krate);
});
impl<'a, 'tcx> LintLevelMapBuilder<'a, 'tcx> {
fn with_lint_attrs<F>(&mut self,
- id: ast::NodeId,
+ id: hir::HirId,
attrs: &[ast::Attribute],
f: F)
where F: FnOnce(&mut Self)
{
let push = self.levels.push(attrs);
- self.levels.register_id(self.tcx.hir().definitions().node_to_hir_id(id));
+ self.levels.register_id(id);
f(self);
self.levels.pop(push);
}
}
fn visit_item(&mut self, it: &'tcx hir::Item) {
- self.with_lint_attrs(it.id, &it.attrs, |builder| {
+ self.with_lint_attrs(it.hir_id, &it.attrs, |builder| {
intravisit::walk_item(builder, it);
});
}
fn visit_foreign_item(&mut self, it: &'tcx hir::ForeignItem) {
- self.with_lint_attrs(it.id, &it.attrs, |builder| {
+ self.with_lint_attrs(it.hir_id, &it.attrs, |builder| {
intravisit::walk_foreign_item(builder, it);
})
}
fn visit_expr(&mut self, e: &'tcx hir::Expr) {
- self.with_lint_attrs(e.id, &e.attrs, |builder| {
+ self.with_lint_attrs(e.hir_id, &e.attrs, |builder| {
intravisit::walk_expr(builder, e);
})
}
fn visit_struct_field(&mut self, s: &'tcx hir::StructField) {
- self.with_lint_attrs(s.id, &s.attrs, |builder| {
+ self.with_lint_attrs(s.hir_id, &s.attrs, |builder| {
intravisit::walk_struct_field(builder, s);
})
}
v: &'tcx hir::Variant,
g: &'tcx hir::Generics,
item_id: hir::HirId) {
- self.with_lint_attrs(v.node.data.id(), &v.node.attrs, |builder| {
+ self.with_lint_attrs(v.node.data.hir_id(), &v.node.attrs, |builder| {
intravisit::walk_variant(builder, v, g, item_id);
})
}
fn visit_local(&mut self, l: &'tcx hir::Local) {
- self.with_lint_attrs(l.id, &l.attrs, |builder| {
+ self.with_lint_attrs(l.hir_id, &l.attrs, |builder| {
intravisit::walk_local(builder, l);
})
}
fn visit_trait_item(&mut self, trait_item: &'tcx hir::TraitItem) {
- self.with_lint_attrs(trait_item.id, &trait_item.attrs, |builder| {
+ self.with_lint_attrs(trait_item.hir_id, &trait_item.attrs, |builder| {
intravisit::walk_trait_item(builder, trait_item);
});
}
fn visit_impl_item(&mut self, impl_item: &'tcx hir::ImplItem) {
- self.with_lint_attrs(impl_item.id, &impl_item.attrs, |builder| {
+ self.with_lint_attrs(impl_item.hir_id, &impl_item.attrs, |builder| {
intravisit::walk_impl_item(builder, impl_item);
});
}
}
}
- fn handle_field_access(&mut self, lhs: &hir::Expr, node_id: ast::NodeId) {
+ fn handle_field_access(&mut self, lhs: &hir::Expr, hir_id: hir::HirId) {
match self.tables.expr_ty_adjusted(lhs).sty {
ty::Adt(def, _) => {
- let index = self.tcx.field_index(node_id, self.tables);
+ let index = self.tcx.field_index(hir_id, self.tables);
self.insert_def_id(def.non_enum_variant().fields[index].did);
}
ty::Tuple(..) => {}
if let PatKind::Wild = pat.node.pat.node {
continue;
}
- let index = self.tcx.field_index(pat.node.id, self.tables);
+ let index = self.tcx.field_index(pat.node.hir_id, self.tables);
self.insert_def_id(variant.fields[index].did);
}
}
fn mark_as_used_if_union(&mut self, adt: &ty::AdtDef, fields: &hir::HirVec<hir::Field>) {
if adt.is_union() && adt.non_enum_variant().fields.len() > 1 && adt.did.is_local() {
for field in fields {
- let index = self.tcx.field_index(field.id, self.tables);
+ let index = self.tcx.field_index(field.hir_id, self.tables);
self.insert_def_id(adt.non_enum_variant().fields[index].did);
}
}
self.lookup_and_handle_method(expr.hir_id);
}
hir::ExprKind::Field(ref lhs, ..) => {
- self.handle_field_access(&lhs, expr.id);
+ self.handle_field_access(&lhs, expr.hir_id);
}
hir::ExprKind::Struct(_, ref fields, _) => {
if let ty::Adt(ref adt, _) = self.tables.expr_ty(expr).sty {
// The value found at `cmt` is either copied or moved, depending
// on mode.
fn consume(&mut self,
- consume_id: ast::NodeId,
+ consume_id: hir::HirId,
consume_span: Span,
cmt: &mc::cmt_<'tcx>,
mode: ConsumeMode);
// The value found at `borrow` is being borrowed at the point
// `borrow_id` for the region `loan_region` with kind `bk`.
fn borrow(&mut self,
- borrow_id: ast::NodeId,
+ borrow_id: hir::HirId,
borrow_span: Span,
cmt: &mc::cmt_<'tcx>,
loan_region: ty::Region<'tcx>,
// The path at `cmt` is being assigned to.
fn mutate(&mut self,
- assignment_id: ast::NodeId,
+ assignment_id: hir::HirId,
assignment_span: Span,
assignee_cmt: &mc::cmt_<'tcx>,
mode: MutateMode);
}
fn delegate_consume(&mut self,
- consume_id: ast::NodeId,
+ consume_id: hir::HirId,
consume_span: Span,
cmt: &mc::cmt_<'tcx>) {
debug!("delegate_consume(consume_id={}, cmt={:?})",
debug!("consume_expr(expr={:?})", expr);
let cmt = return_if_err!(self.mc.cat_expr(expr));
- self.delegate_consume(expr.id, expr.span, &cmt);
+ self.delegate_consume(expr.hir_id, expr.span, &cmt);
self.walk_expr(expr);
}
expr: &hir::Expr,
mode: MutateMode) {
let cmt = return_if_err!(self.mc.cat_expr(expr));
- self.delegate.mutate(assignment_expr.id, span, &cmt, mode);
+ self.delegate.mutate(assignment_expr.hir_id, span, &cmt, mode);
self.walk_expr(expr);
}
expr, r, bk);
let cmt = return_if_err!(self.mc.cat_expr(expr));
- self.delegate.borrow(expr.id, expr.span, &cmt, r, bk, cause);
+ self.delegate.borrow(expr.hir_id, expr.span, &cmt, r, bk, cause);
self.walk_expr(expr)
}
// Consume those fields of the with expression that are needed.
for (f_index, with_field) in adt.non_enum_variant().fields.iter().enumerate() {
let is_mentioned = fields.iter().any(|f| {
- self.tcx().field_index(f.id, self.mc.tables) == f_index
+ self.tcx().field_index(f.hir_id, self.mc.tables) == f_index
});
if !is_mentioned {
let cmt_field = self.mc.cat_field(
with_field.ident,
with_field.ty(self.tcx(), substs)
);
- self.delegate_consume(with_expr.id, with_expr.span, &cmt_field);
+ self.delegate_consume(with_expr.hir_id, with_expr.span, &cmt_field);
}
}
}
adjustment::Adjust::Unsize => {
// Creating a closure/fn-pointer or unsizing consumes
// the input and stores it into the resulting rvalue.
- self.delegate_consume(expr.id, expr.span, &cmt);
+ self.delegate_consume(expr.hir_id, expr.span, &cmt);
}
adjustment::Adjust::Deref(None) => {}
// this is an autoref of `x`.
adjustment::Adjust::Deref(Some(ref deref)) => {
let bk = ty::BorrowKind::from_mutbl(deref.mutbl);
- self.delegate.borrow(expr.id, expr.span, &cmt, deref.region, bk, AutoRef);
+ self.delegate.borrow(expr.hir_id, expr.span, &cmt, deref.region, bk, AutoRef);
}
adjustment::Adjust::Borrow(ref autoref) => {
expr: &hir::Expr,
cmt_base: &mc::cmt_<'tcx>,
autoref: &adjustment::AutoBorrow<'tcx>) {
- debug!("walk_autoref(expr.id={} cmt_base={:?} autoref={:?})",
- expr.id,
+ debug!("walk_autoref(expr.hir_id={} cmt_base={:?} autoref={:?})",
+ expr.hir_id,
cmt_base,
autoref);
match *autoref {
adjustment::AutoBorrow::Ref(r, m) => {
- self.delegate.borrow(expr.id,
+ self.delegate.borrow(expr.hir_id,
expr.span,
cmt_base,
r,
}
adjustment::AutoBorrow::RawPtr(m) => {
- debug!("walk_autoref: expr.id={} cmt_base={:?}",
- expr.id,
+ debug!("walk_autoref: expr.hir_id={} cmt_base={:?}",
+ expr.hir_id,
cmt_base);
// Converting from a &T to *T (or &mut T to *mut T) is
data: region::ScopeData::Node
}));
- self.delegate.borrow(expr.id,
+ self.delegate.borrow(expr.hir_id,
expr.span,
cmt_base,
r,
// binding being produced.
let def = Def::Local(canonical_id);
if let Ok(ref binding_cmt) = mc.cat_def(pat.hir_id, pat.span, pat_ty, def) {
- delegate.mutate(pat.id, pat.span, binding_cmt, MutateMode::Init);
+ delegate.mutate(pat.hir_id, pat.span, binding_cmt, MutateMode::Init);
}
// It is also a borrow or copy/move of the value being matched.
ty::BindByReference(m) => {
if let ty::Ref(r, _, _) = pat_ty.sty {
let bk = ty::BorrowKind::from_mutbl(m);
- delegate.borrow(pat.id, pat.span, &cmt_pat, r, bk, RefBinding);
+ delegate.borrow(pat.hir_id, pat.span, &cmt_pat, r, bk, RefBinding);
}
}
ty::BindByValue(..) => {
fn walk_captures(&mut self, closure_expr: &hir::Expr, fn_decl_span: Span) {
debug!("walk_captures({:?})", closure_expr);
- self.tcx().with_freevars(closure_expr.id, |freevars| {
+ let closure_node_id = self.tcx().hir().hir_to_node_id(closure_expr.hir_id);
+ let closure_def_id = self.tcx().hir().local_def_id(closure_node_id);
+ self.tcx().with_freevars(closure_node_id, |freevars| {
for freevar in freevars {
let var_hir_id = self.tcx().hir().node_to_hir_id(freevar.var_id());
- let closure_def_id = self.tcx().hir().local_def_id(closure_expr.id);
let upvar_id = ty::UpvarId {
var_path: ty::UpvarPath { hir_id: var_hir_id },
closure_expr_id: closure_def_id.to_local(),
self.param_env,
&cmt_var,
CaptureMove);
- self.delegate.consume(closure_expr.id, freevar.span, &cmt_var, mode);
+ self.delegate.consume(closure_expr.hir_id, freevar.span, &cmt_var, mode);
}
ty::UpvarCapture::ByRef(upvar_borrow) => {
- self.delegate.borrow(closure_expr.id,
+ self.delegate.borrow(closure_expr.hir_id,
fn_decl_span,
&cmt_var,
upvar_borrow.region,
num_vars: usize,
live_node_map: HirIdMap<LiveNode>,
variable_map: HirIdMap<Variable>,
- capture_info_map: NodeMap<Rc<Vec<CaptureInfo>>>,
+ capture_info_map: HirIdMap<Rc<Vec<CaptureInfo>>>,
var_kinds: Vec<VarKind>,
lnks: Vec<LiveNodeKind>,
}
}
}
- fn set_captures(&mut self, node_id: NodeId, cs: Vec<CaptureInfo>) {
- self.capture_info_map.insert(node_id, Rc::new(cs));
+ fn set_captures(&mut self, hir_id: HirId, cs: Vec<CaptureInfo>) {
+ self.capture_info_map.insert(hir_id, Rc::new(cs));
}
fn lnk(&self, ln: LiveNode) -> LiveNodeKind {
match expr.node {
// live nodes required for uses or definitions of variables:
hir::ExprKind::Path(hir::QPath::Resolved(_, ref path)) => {
- debug!("expr {}: path that leads to {:?}", expr.id, path.def);
+ debug!("expr {}: path that leads to {:?}", expr.hir_id, path.def);
if let Def::Local(..) = path.def {
ir.add_live_node_for_node(expr.hir_id, ExprNode(expr.span));
}
// in better error messages than just pointing at the closure
// construction site.
let mut call_caps = Vec::new();
- ir.tcx.with_freevars(expr.id, |freevars| {
+ let node_id = ir.tcx.hir().hir_to_node_id(expr.hir_id);
+ ir.tcx.with_freevars(node_id, |freevars| {
call_caps.extend(freevars.iter().filter_map(|fv| {
if let Def::Local(rv) = fv.def {
let fv_ln = ir.add_live_node(FreeVarNode(fv.span));
}
}));
});
- ir.set_captures(expr.id, call_caps);
+ ir.set_captures(expr.hir_id, call_caps);
intravisit::walk_expr(ir, expr);
}
}
fn compute(&mut self, body: &hir::Expr) -> LiveNode {
- debug!("compute: using id for body, {}", self.ir.tcx.hir().node_to_pretty_string(body.id));
+ debug!("compute: using id for body, {}",
+ self.ir.tcx.hir().hir_to_pretty_string(body.hir_id));
// the fallthrough exit is only for those cases where we do not
// explicitly return:
for ln_idx in 0..self.ir.num_live_nodes {
debug!("{:?}", self.ln_str(LiveNode(ln_idx as u32)));
}
- body.id
+ body.hir_id
},
entry_ln);
fn propagate_through_expr(&mut self, expr: &Expr, succ: LiveNode)
-> LiveNode {
- debug!("propagate_through_expr: {}", self.ir.tcx.hir().node_to_pretty_string(expr.id));
+ debug!("propagate_through_expr: {}", self.ir.tcx.hir().hir_to_pretty_string(expr.hir_id));
match expr.node {
// Interesting cases with control flow or which gen/kill
hir::ExprKind::Closure(..) => {
debug!("{} is an ExprKind::Closure",
- self.ir.tcx.hir().node_to_pretty_string(expr.id));
+ self.ir.tcx.hir().hir_to_pretty_string(expr.hir_id));
// the construction of a closure itself is not important,
// but we have to consider the closed over variables.
- let caps = self.ir.capture_info_map.get(&expr.id).cloned().unwrap_or_else(||
+ let caps = self.ir.capture_info_map.get(&expr.hir_id).cloned().unwrap_or_else(||
span_bug!(expr.span, "no registered caps"));
caps.iter().rev().fold(succ, |succ, cap| {
}
hir::ExprKind::Call(ref f, ref args) => {
- let m = self.ir.tcx.hir().get_module_parent(expr.id);
+ let m = self.ir.tcx.hir().get_module_parent_by_hir_id(expr.hir_id);
let succ = if self.ir.tcx.is_ty_uninhabited_from(m, self.tables.expr_ty(expr)) {
self.s.exit_ln
} else {
}
hir::ExprKind::MethodCall(.., ref args) => {
- let m = self.ir.tcx.hir().get_module_parent(expr.id);
+ let m = self.ir.tcx.hir().get_module_parent_by_hir_id(expr.hir_id);
let succ = if self.ir.tcx.is_ty_uninhabited_from(m, self.tables.expr_ty(expr)) {
self.s.exit_ln
} else {
}
}
debug!("propagate_through_loop: using id for loop body {} {}",
- expr.id, self.ir.tcx.hir().hir_to_pretty_string(body.hir_id));
+ expr.hir_id, self.ir.tcx.hir().hir_to_pretty_string(body.hir_id));
-
- self.break_ln.insert(expr.id, succ);
+ let node_id = self.ir.tcx.hir().hir_to_node_id(expr.hir_id);
+ self.break_ln.insert(node_id, succ);
let cond_ln = match kind {
LoopLoop => ln,
WhileLoop(ref cond) => self.propagate_through_expr(&cond, ln),
};
- self.cont_ln.insert(expr.id, cond_ln);
+ self.cont_ln.insert(node_id, cond_ln);
let body_ln = self.propagate_through_block(body, cond_ln);
}
pub fn cat_expr_unadjusted(&self, expr: &hir::Expr) -> McResult<cmt_<'tcx>> {
- debug!("cat_expr: id={} expr={:?}", expr.id, expr);
+ debug!("cat_expr: id={} expr={:?}", expr.hir_id, expr);
let expr_ty = self.expr_ty(expr)?;
match expr.node {
hir::ExprKind::Field(ref base, f_ident) => {
let base_cmt = Rc::new(self.cat_expr(&base)?);
debug!("cat_expr(cat_field): id={} expr={:?} base={:?}",
- expr.id,
+ expr.hir_id,
expr,
base_cmt);
- let f_index = self.tcx.field_index(expr.id, self.tables);
+ let f_index = self.tcx.field_index(expr.hir_id, self.tables);
Ok(self.cat_field(expr, base_cmt, f_index, f_ident, expr_ty))
}
for fp in field_pats {
let field_ty = self.pat_ty_adjusted(&fp.node.pat)?; // see (*2)
- let f_index = self.tcx.field_index(fp.node.id, self.tables);
+ let f_index = self.tcx.field_index(fp.node.hir_id, self.tables);
let cmt_field = Rc::new(self.cat_field(pat, cmt.clone(), f_index,
fp.node.ident, field_ty));
self.cat_pattern_(cmt_field, &fp.node.pat, op)?;
use syntax::symbol::Symbol;
use syntax_pos::{Span, MultiSpan};
use syntax::ast;
-use syntax::ast::{NodeId, Attribute};
+use syntax::ast::Attribute;
use syntax::errors::Applicability;
use syntax::feature_gate::{GateIssue, emit_feature_err};
use syntax::attr::{self, Stability, Deprecation};
/// If `id` is `Some(_)`, this function will also check if the item at `def_id` has been
/// deprecated. If the item is indeed deprecated, we will emit a deprecation lint attached to
/// `id`.
- pub fn eval_stability(self, def_id: DefId, id: Option<NodeId>, span: Span) -> EvalResult {
+ pub fn eval_stability(self, def_id: DefId, id: Option<HirId>, span: Span) -> EvalResult {
let lint_deprecated = |def_id: DefId,
- id: NodeId,
+ id: HirId,
note: Option<Symbol>,
suggestion: Option<Symbol>,
message: &str,
format!("{}", message)
};
- let mut diag = self.struct_span_lint_node(lint, id, span, &msg);
+ let mut diag = self.struct_span_lint_hir(lint, id, span, &msg);
if let Some(suggestion) = suggestion {
- if let hir::Node::Expr(_) = self.hir().get(id) {
+ if let hir::Node::Expr(_) = self.hir().get_by_hir_id(id) {
diag.span_suggestion(
span,
&msg,
}
}
diag.emit();
- if id == ast::DUMMY_NODE_ID {
- span_bug!(span, "emitted a {} lint with dummy node id: {:?}", lint.name, def_id);
+ if id == hir::DUMMY_HIR_ID {
+ span_bug!(span, "emitted a {} lint with dummy HIR id: {:?}", lint.name, def_id);
}
};
// Deprecated attributes apply in-crate and cross-crate.
if let Some(id) = id {
if let Some(depr_entry) = self.lookup_deprecation_entry(def_id) {
- let parent_def_id = self.hir().local_def_id(self.hir().get_parent(id));
+ let parent_def_id = self.hir().local_def_id_from_hir_id(
+ self.hir().get_parent_item(id));
let skip = self.lookup_deprecation_entry(parent_def_id)
.map_or(false, |parent_depr| parent_depr.same_origin(&depr_entry));
///
/// Additionally, this function will also check if the item is deprecated. If so, and `id` is
/// not `None`, a deprecated lint attached to `id` will be emitted.
- pub fn check_stability(self, def_id: DefId, id: Option<NodeId>, span: Span) {
+ pub fn check_stability(self, def_id: DefId, id: Option<HirId>, span: Span) {
match self.eval_stability(def_id, id, span) {
EvalResult::Allow => {}
EvalResult::Deny { feature, reason, issue } => {
None => return,
};
let def_id = DefId { krate: cnum, index: CRATE_DEF_INDEX };
- self.tcx.check_stability(def_id, Some(item.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
}
fn visit_path(&mut self, path: &'tcx hir::Path, id: hir::HirId) {
- let id = self.tcx.hir().hir_to_node_id(id);
if let Some(def_id) = path.def.opt_def_id() {
self.tcx.check_stability(def_id, Some(id), path.span)
}
ReturnNoExpression,
/// `return` with an expression
- ReturnType(ast::NodeId),
+ ReturnType(hir::HirId),
/// Block implicit return
- BlockTailExpression(ast::NodeId),
+ BlockTailExpression(hir::HirId),
/// #[feature(trivial_bounds)] is not enabled
TrivialBound,
}
}
- pub fn field_index(self, node_id: NodeId, tables: &TypeckTables<'_>) -> usize {
- let hir_id = self.hir().node_to_hir_id(node_id);
+ pub fn field_index(self, hir_id: hir::HirId, tables: &TypeckTables<'_>) -> usize {
tables.field_indices().get(hir_id).cloned().expect("no index for a field")
}
impl<'a, 'tcx> euv::Delegate<'tcx> for CheckLoanCtxt<'a, 'tcx> {
fn consume(&mut self,
- consume_id: ast::NodeId,
+ consume_id: hir::HirId,
consume_span: Span,
cmt: &mc::cmt_<'tcx>,
mode: euv::ConsumeMode) {
debug!("consume(consume_id={}, cmt={:?}, mode={:?})",
consume_id, cmt, mode);
- let hir_id = self.tcx().hir().node_to_hir_id(consume_id);
- self.consume_common(hir_id.local_id, consume_span, cmt, mode);
+ self.consume_common(consume_id.local_id, consume_span, cmt, mode);
}
fn matched_pat(&mut self,
}
fn borrow(&mut self,
- borrow_id: ast::NodeId,
+ borrow_id: hir::HirId,
borrow_span: Span,
cmt: &mc::cmt_<'tcx>,
loan_region: ty::Region<'tcx>,
borrow_id, cmt, loan_region,
bk, loan_cause);
- let hir_id = self.tcx().hir().node_to_hir_id(borrow_id);
if let Some(lp) = opt_loan_path(cmt) {
let moved_value_use_kind = match loan_cause {
euv::ClosureCapture(_) => MovedInCapture,
_ => MovedInUse,
};
- self.check_if_path_is_moved(hir_id.local_id, borrow_span, moved_value_use_kind, &lp);
+ self.check_if_path_is_moved(borrow_id.local_id, borrow_span, moved_value_use_kind, &lp);
}
- self.check_for_conflicting_loans(hir_id.local_id);
+ self.check_for_conflicting_loans(borrow_id.local_id);
self.check_for_loans_across_yields(cmt, loan_region, borrow_span);
}
fn mutate(&mut self,
- assignment_id: ast::NodeId,
+ assignment_id: hir::HirId,
assignment_span: Span,
assignee_cmt: &mc::cmt_<'tcx>,
mode: euv::MutateMode)
}
}
}
- self.check_assignment(self.tcx().hir().node_to_hir_id(assignment_id).local_id,
- assignment_span, assignee_cmt);
+ self.check_assignment(assignment_id.local_id, assignment_span, assignee_cmt);
}
fn decl_without_init(&mut self, _id: ast::NodeId, _span: Span) { }
move_data: &move_data::FlowedMoveData<'c, 'tcx>,
all_loans: &[Loan<'tcx>],
body: &hir::Body) {
- debug!("check_loans(body id={})", body.value.id);
+ debug!("check_loans(body id={})", body.value.hir_id);
let def_id = bccx.tcx.hir().body_owner_def_id(body.id());
impl<'a, 'tcx> euv::Delegate<'tcx> for GatherLoanCtxt<'a, 'tcx> {
fn consume(&mut self,
- consume_id: ast::NodeId,
+ consume_id: hir::HirId,
_consume_span: Span,
cmt: &mc::cmt_<'tcx>,
mode: euv::ConsumeMode) {
euv::Move(move_reason) => {
gather_moves::gather_move_from_expr(
self.bccx, &self.move_data, &mut self.move_error_collector,
- self.bccx.tcx.hir().node_to_hir_id(consume_id).local_id, cmt, move_reason);
+ consume_id.local_id, cmt, move_reason);
}
euv::Copy => { }
}
}
fn borrow(&mut self,
- borrow_id: ast::NodeId,
+ borrow_id: hir::HirId,
borrow_span: Span,
cmt: &mc::cmt_<'tcx>,
loan_region: ty::Region<'tcx>,
bk={:?}, loan_cause={:?})",
borrow_id, cmt, loan_region,
bk, loan_cause);
- let hir_id = self.bccx.tcx.hir().node_to_hir_id(borrow_id);
- self.guarantee_valid(hir_id.local_id,
+
+ self.guarantee_valid(borrow_id.local_id,
borrow_span,
cmt,
bk,
}
fn mutate(&mut self,
- assignment_id: ast::NodeId,
+ assignment_id: hir::HirId,
assignment_span: Span,
assignee_cmt: &mc::cmt_<'tcx>,
_: euv::MutateMode)
{
- self.guarantee_assignment_valid(assignment_id,
+ let node_id = self.bccx.tcx.hir().hir_to_node_id(assignment_id);
+ self.guarantee_assignment_valid(node_id,
assignment_span,
assignee_cmt);
}
}
pprust_hir::AnnNode::Expr(expr) => {
s.s.space()?;
- s.synth_comment(format!("node_id: {} hir local_id: {}",
- expr.id, expr.hir_id.local_id.as_u32()))?;
+ s.synth_comment(format!("expr hir_id: {} hir local_id: {}",
+ expr.hir_id, expr.hir_id.local_id.as_u32()))?;
s.pclose()
}
pprust_hir::AnnNode::Pat(pat) => {
let body_id = match code {
blocks::Code::Expr(expr) => {
// Find the function this expression is from.
- let mut node_id = expr.id;
+ let mut hir_id = expr.hir_id;
loop {
- let node = tcx.hir().get(node_id);
+ let node = tcx.hir().get_by_hir_id(hir_id);
if let Some(n) = hir::map::blocks::FnLikeNode::from_node(node) {
break n.body();
}
- let parent = tcx.hir().get_parent_node(node_id);
- assert_ne!(node_id, parent);
- node_id = parent;
+ let parent = tcx.hir().get_parent_node_by_hir_id(hir_id);
+ assert_ne!(hir_id, parent);
+ hir_id = parent;
}
}
blocks::Code::FnLike(fn_like) => fn_like.body(),
}
if let PatKind::Binding(_, _, _, ident, None) = fieldpat.node.pat.node {
if cx.tcx.find_field_index(ident, &variant) ==
- Some(cx.tcx.field_index(fieldpat.node.id, cx.tables)) {
+ Some(cx.tcx.field_index(fieldpat.node.hir_id, cx.tables)) {
let mut err = cx.struct_span_lint(NON_SHORTHAND_FIELD_PATTERNS,
fieldpat.span,
&format!("the `{}:` in this pattern is redundant", ident));
#[derive(Copy, Clone)]
pub struct TypeLimits {
/// Id of the last visited negated expression
- negated_expr_id: ast::NodeId,
+ negated_expr_id: hir::HirId,
}
impl TypeLimits {
pub fn new() -> TypeLimits {
- TypeLimits { negated_expr_id: ast::DUMMY_NODE_ID }
+ TypeLimits { negated_expr_id: hir::DUMMY_HIR_ID }
}
}
match e.node {
hir::ExprKind::Unary(hir::UnNeg, ref expr) => {
// propagate negation, if the negation itself isn't negated
- if self.negated_expr_id != e.id {
- self.negated_expr_id = expr.id;
+ if self.negated_expr_id != e.hir_id {
+ self.negated_expr_id = expr.hir_id;
}
}
hir::ExprKind::Binary(binop, ref l, ref r) => {
};
let (_, max) = int_ty_range(int_type);
let max = max as u128;
- let negative = self.negated_expr_id == e.id;
+ let negative = self.negated_expr_id == e.hir_id;
// Detect literal value out of range [min, max] inclusive
// avoiding use of -min to prevent overflow/panic
_ => bug!(),
};
if lit_val < min || lit_val > max {
- let parent_id = cx.tcx.hir().get_parent_node(e.id);
- if let Node::Expr(parent_expr) = cx.tcx.hir().get(parent_id) {
+ let parent_id = cx.tcx.hir().get_parent_node_by_hir_id(e.hir_id);
+ if let Node::Expr(parent_expr) = cx.tcx.hir().get_by_hir_id(parent_id) {
if let hir::ExprKind::Cast(..) = parent_expr.node {
if let ty::Char = cx.tables.expr_ty(parent_expr).sty {
let mut err = cx.struct_span_lint(
let t = cx.tables.expr_ty(&expr);
let type_permits_lack_of_use = if t.is_unit()
- || cx.tcx.is_ty_uninhabited_from(cx.tcx.hir().get_module_parent(expr.id), t) {
+ || cx.tcx.is_ty_uninhabited_from(
+ cx.tcx.hir().get_module_parent_by_hir_id(expr.hir_id), t)
+ {
true
} else {
match t.sty {
fn encode_info_for_expr(&mut self, expr: &hir::Expr) {
match expr.node {
hir::ExprKind::Closure(..) => {
- let def_id = self.tcx.hir().local_def_id(expr.id);
+ let def_id = self.tcx.hir().local_def_id_from_hir_id(expr.hir_id);
self.record(def_id, IsolatedEncoder::encode_info_for_closure, def_id);
}
_ => {}
},
pattern,
initializer: local.init.to_ref(),
- lint_level: cx.lint_level_of(local.id),
+ lint_level: cx.lint_level_of(local.hir_id),
},
opt_destruction_scope: opt_dxn_ext,
span: stmt_span,
data: region::ScopeData::Node
};
- debug!("Expr::make_mirror(): id={}, span={:?}", self.id, self.span);
+ debug!("Expr::make_mirror(): id={}, span={:?}", self.hir_id, self.span);
let mut expr = make_mirror_unadjusted(cx, self);
kind: ExprKind::Scope {
region_scope: expr_scope,
value: expr.to_ref(),
- lint_level: cx.lint_level_of(self.id),
+ lint_level: cx.lint_level_of(self.hir_id),
},
};
span_bug!(expr.span, "closure expr w/o closure type: {:?}", closure_ty);
}
};
- let upvars = cx.tcx.with_freevars(expr.id, |freevars| {
+ let expr_node_id = cx.tcx.hir().hir_to_node_id(expr.hir_id);
+ let upvars = cx.tcx.with_freevars(expr_node_id, |freevars| {
freevars.iter()
.zip(substs.upvar_tys(def_id, cx.tcx))
.map(|(fv, ty)| capture_freevar(cx, expr, fv, ty))
hir::ExprKind::Field(ref source, ..) => {
ExprKind::Field {
lhs: source.to_ref(),
- name: Field::new(cx.tcx.field_index(expr.id, cx.tables)),
+ name: Field::new(cx.tcx.field_index(expr.hir_id, cx.tables)),
}
}
hir::ExprKind::Cast(ref source, ref cast_ty) => {
let var_hir_id = cx.tcx.hir().node_to_hir_id(freevar.var_id());
let upvar_id = ty::UpvarId {
var_path: ty::UpvarPath { hir_id: var_hir_id },
- closure_expr_id: cx.tcx.hir().local_def_id(closure_expr.id).to_local(),
+ closure_expr_id: cx.tcx.hir().local_def_id_from_hir_id(closure_expr.hir_id).to_local(),
};
let upvar_capture = cx.tables().upvar_capture(upvar_id);
let temp_lifetime = cx.region_scope_tree.temporary_scope(closure_expr.hir_id.local_id);
fields.iter()
.map(|field| {
FieldExprRef {
- name: Field::new(cx.tcx.field_index(field.id, cx.tables)),
+ name: Field::new(cx.tcx.field_index(field.hir_id, cx.tables)),
expr: field.expr.to_ref(),
}
})
ty.needs_drop(self.tcx.global_tcx(), param_env)
}
- fn lint_level_of(&self, node_id: ast::NodeId) -> LintLevel {
- let hir_id = self.tcx.hir().definitions().node_to_hir_id(node_id);
+ fn lint_level_of(&self, hir_id: hir::HirId) -> LintLevel {
let has_lint_level = self.tcx.dep_graph.with_ignore(|| {
self.tcx.lint_levels(LOCAL_CRATE).lint_level_set(hir_id).is_some()
});
}
}
- let module = self.tcx.hir().get_module_parent(scrut.id);
+ let module = self.tcx.hir().get_module_parent_by_hir_id(scrut.hir_id);
MatchCheckCtxt::create_and_enter(self.tcx, self.param_env, module, |ref mut cx| {
let mut have_errors = false;
// Then, if the match has no arms, check whether the scrutinee
// is uninhabited.
let pat_ty = self.tables.node_type(scrut.hir_id);
- let module = self.tcx.hir().get_module_parent(scrut.id);
+ let module = self.tcx.hir().get_module_parent_by_hir_id(scrut.hir_id);
if inlined_arms.is_empty() {
let scrutinee_is_uninhabited = if self.tcx.features().exhaustive_patterns {
self.tcx.is_ty_uninhabited_from(module, pat_ty)
impl<'a, 'tcx> Delegate<'tcx> for MutationChecker<'a, 'tcx> {
fn matched_pat(&mut self, _: &Pat, _: &cmt_<'_>, _: euv::MatchMode) {}
- fn consume(&mut self, _: ast::NodeId, _: Span, _: &cmt_<'_>, _: ConsumeMode) {}
+ fn consume(&mut self, _: hir::HirId, _: Span, _: &cmt_<'_>, _: ConsumeMode) {}
fn consume_pat(&mut self, _: &Pat, _: &cmt_<'_>, _: ConsumeMode) {}
fn borrow(&mut self,
- _: ast::NodeId,
+ _: hir::HirId,
span: Span,
_: &cmt_<'_>,
_: ty::Region<'tcx>,
}
}
fn decl_without_init(&mut self, _: ast::NodeId, _: Span) {}
- fn mutate(&mut self, _: ast::NodeId, span: Span, _: &cmt_<'_>, mode: MutateMode) {
+ fn mutate(&mut self, _: hir::HirId, span: Span, _: &cmt_<'_>, mode: MutateMode) {
match mode {
MutateMode::JustWrite | MutateMode::WriteAndRead => {
struct_span_err!(self.cx.tcx.sess, span, E0302, "cannot assign in a pattern guard")
fields.iter()
.map(|field| {
FieldPattern {
- field: Field::new(self.tcx.field_index(field.node.id,
+ field: Field::new(self.tcx.field_index(field.node.hir_id,
self.tables)),
pattern: self.lower_pattern(&field.node.pat),
}
use rustc::ty::{self, Ty, TyCtxt};
use rustc::ty::query::Providers;
use rustc::ty::subst::Substs;
-use rustc::util::nodemap::{ItemLocalSet, NodeSet};
+use rustc::util::nodemap::{ItemLocalSet, HirIdSet};
use rustc::hir;
use rustc_data_structures::sync::Lrc;
use syntax::ast;
tcx: TyCtxt<'a, 'tcx, 'tcx>,
in_fn: bool,
in_static: bool,
- mut_rvalue_borrows: NodeSet,
+ mut_rvalue_borrows: HirIdSet,
param_env: ty::ParamEnv<'tcx>,
identity_substs: &'tcx Substs<'tcx>,
tables: &'a ty::TypeckTables<'tcx>,
fn remove_mut_rvalue_borrow(&mut self, pat: &hir::Pat) -> bool {
let mut any_removed = false;
pat.walk(|p| {
- any_removed |= self.mut_rvalue_borrows.remove(&p.id);
+ any_removed |= self.mut_rvalue_borrows.remove(&p.hir_id);
true
});
any_removed
hir::StmtKind::Local(ref local) => {
if self.remove_mut_rvalue_borrow(&local.pat) {
if let Some(init) = &local.init {
- self.mut_rvalue_borrows.insert(init.id);
+ self.mut_rvalue_borrows.insert(init.hir_id);
}
}
outer &= check_adjustments(self, ex);
// Handle borrows on (or inside the autorefs of) this expression.
- if self.mut_rvalue_borrows.remove(&ex.id) {
+ if self.mut_rvalue_borrows.remove(&ex.hir_id) {
outer = NotPromotable
}
}
hir::ExprKind::Cast(ref from, _) => {
let expr_promotability = v.check_expr(from);
- debug!("Checking const cast(id={})", from.id);
+ debug!("Checking const cast(id={})", from.hir_id);
match v.tables.cast_kinds().get(from.hir_id) {
None => {
v.tcx.sess.delay_span_bug(e.span, "no kind for cast");
hir::ExprKind::Closure(_capture_clause, ref _box_fn_decl,
body_id, _span, _option_generator_movability) => {
let nested_body_promotable = v.check_nested_body(body_id);
+ let node_id = v.tcx.hir().hir_to_node_id(e.hir_id);
// Paths in constant contexts cannot refer to local variables,
// as there are none, and thus closures can't have upvars there.
- if v.tcx.with_freevars(e.id, |fv| !fv.is_empty()) {
+ if v.tcx.with_freevars(node_id, |fv| !fv.is_empty()) {
NotPromotable
} else {
nested_body_promotable
mut_borrow = v.remove_mut_rvalue_borrow(pat);
}
if mut_borrow {
- v.mut_rvalue_borrows.insert(expr.id);
+ v.mut_rvalue_borrows.insert(expr.hir_id);
}
let _ = v.check_expr(expr);
impl<'a, 'gcx, 'tcx> euv::Delegate<'tcx> for CheckCrateVisitor<'a, 'gcx> {
fn consume(&mut self,
- _consume_id: ast::NodeId,
+ _consume_id: hir::HirId,
_consume_span: Span,
_cmt: &mc::cmt_<'_>,
_mode: euv::ConsumeMode) {}
fn borrow(&mut self,
- borrow_id: ast::NodeId,
+ borrow_id: hir::HirId,
_borrow_span: Span,
cmt: &mc::cmt_<'tcx>,
_loan_region: ty::Region<'tcx>,
fn decl_without_init(&mut self, _id: ast::NodeId, _span: Span) {}
fn mutate(&mut self,
- _assignment_id: ast::NodeId,
+ _assignment_id: hir::HirId,
_assignment_span: Span,
_assignee_cmt: &mc::cmt_<'_>,
_mode: euv::MutateMode) {
return (ctor_vis, span, descr);
}
Node::Expr(expr) => {
- return (ty::Visibility::Restricted(tcx.hir().get_module_parent(expr.id)),
+ return (ty::Visibility::Restricted(
+ tcx.hir().get_module_parent_by_hir_id(expr.hir_id)),
expr.span, "private")
}
node => bug!("unexpected node kind: {:?}", node)
// unmentioned fields, just check them all.
for (vf_index, variant_field) in variant.fields.iter().enumerate() {
let field = fields.iter().find(|f| {
- self.tcx.field_index(f.id, self.tables) == vf_index
+ self.tcx.field_index(f.hir_id, self.tables) == vf_index
});
let (use_ctxt, span) = match field {
Some(field) => (field.ident.span, field.span),
} else {
for field in fields {
let use_ctxt = field.ident.span;
- let index = self.tcx.field_index(field.id, self.tables);
+ let index = self.tcx.field_index(field.hir_id, self.tables);
self.check_field(use_ctxt, field.span, adt, &variant.fields[index]);
}
}
let variant = adt.variant_of_def(def);
for field in fields {
let use_ctxt = field.node.ident.span;
- let index = self.tcx.field_index(field.node.id, self.tables);
+ let index = self.tcx.field_index(field.node.hir_id, self.tables);
self.check_field(use_ctxt, field.span, adt, &variant.fields[index]);
}
}
return;
}
};
- let def = self.save_ctxt.get_path_def(hir_expr.id);
+ let node_id = self.save_ctxt.tcx.hir().hir_to_node_id(hir_expr.hir_id);
+ let def = self.save_ctxt.get_path_def(node_id);
self.process_struct_lit(ex, path, fields, adt.variant_of_def(def), base)
}
ast::ExprKind::MethodCall(ref seg, ref args) => self.process_method_call(ex, seg, args),
let msg = format!("associated type `{}` is private", binding.item_name);
tcx.sess.span_err(binding.span, &msg);
}
- tcx.check_stability(assoc_ty.def_id, Some(ref_id), binding.span);
+ tcx.check_stability(assoc_ty.def_id, Some(hir_ref_id), binding.span);
if !speculative {
dup_bindings.entry(assoc_ty.def_id)
) -> (Ty<'tcx>, Def) {
let tcx = self.tcx();
let assoc_ident = assoc_segment.ident;
- let ref_id = tcx.hir().hir_to_node_id(hir_ref_id);
debug!("associated_path_to_ty: {:?}::{}", qself_ty, assoc_ident);
let def = Def::Variant(variant_def.did);
if permit_variants {
check_type_alias_enum_variants_enabled(tcx, span);
- tcx.check_stability(variant_def.did, Some(ref_id), span);
+ tcx.check_stability(variant_def.did, Some(hir_ref_id), span);
return (qself_ty, def);
} else {
variant_resolution = Some(def);
let msg = format!("{} `{}` is private", def.kind_name(), assoc_ident);
tcx.sess.span_err(span, &msg);
}
- tcx.check_stability(item.def_id, Some(ref_id), span);
+ tcx.check_stability(item.def_id, Some(hir_ref_id), span);
if let Some(variant_def) = variant_resolution {
let mut err = tcx.struct_span_lint_hir(
}
}
PatKind::Path(ref qpath) => {
- let (def, _, _) = self.resolve_ty_and_def_ufcs(qpath, pat.id, pat.span);
+ let (def, _, _) = self.resolve_ty_and_def_ufcs(qpath, pat.hir_id, pat.span);
match def {
Def::Const(..) | Def::AssociatedConst(..) => false,
_ => true,
if self.diverges.get().always() {
for arm in arms {
- self.warn_if_unreachable(arm.body.id, arm.body.span, "arm");
+ self.warn_if_unreachable(arm.body.hir_id, arm.body.span, "arm");
}
}
let cause = if i == 0 {
// The reason for the first arm to fail is not that the match arms diverge,
// but rather that there's a prior obligation that doesn't hold.
- self.cause(arm_span, ObligationCauseCode::BlockTailExpression(arm.body.id))
+ self.cause(arm_span, ObligationCauseCode::BlockTailExpression(arm.body.hir_id))
} else {
self.cause(expr.span, ObligationCauseCode::MatchExpressionArm {
arm_span,
) -> Ty<'tcx>
{
// Resolve the path and check the definition for errors.
- let (variant, pat_ty) = if let Some(variant_ty) = self.check_struct_path(qpath, pat.id) {
+ let (variant, pat_ty) = if let Some(variant_ty) = self.check_struct_path(qpath, pat.hir_id)
+ {
variant_ty
} else {
for field in fields {
self.demand_eqtype_pat(pat.span, expected, pat_ty, match_discrim_span);
// Type-check subpatterns.
- if self.check_struct_pat_fields(pat_ty, pat.id, pat.span, variant, fields, etc, def_bm) {
+ if self.check_struct_pat_fields(pat_ty, pat.hir_id, pat.span, variant, fields, etc, def_bm)
+ {
pat_ty
} else {
self.tcx.types.err
let tcx = self.tcx;
// Resolve the path and check the definition for errors.
- let (def, opt_ty, segments) = self.resolve_ty_and_def_ufcs(qpath, pat.id, pat.span);
+ let (def, opt_ty, segments) = self.resolve_ty_and_def_ufcs(qpath, pat.hir_id, pat.span);
match def {
Def::Err => {
self.set_tainted_by_errors();
}
// Type-check the path.
- let pat_ty = self.instantiate_value_path(segments, opt_ty, def, pat.span, pat.id).0;
+ let pat_ty = self.instantiate_value_path(segments, opt_ty, def, pat.span, pat.hir_id).0;
self.demand_suptype(pat.span, expected, pat_ty);
pat_ty
}
};
// Resolve the path and check the definition for errors.
- let (def, opt_ty, segments) = self.resolve_ty_and_def_ufcs(qpath, pat.id, pat.span);
+ let (def, opt_ty, segments) = self.resolve_ty_and_def_ufcs(qpath, pat.hir_id, pat.span);
if def == Def::Err {
self.set_tainted_by_errors();
on_error();
}
// Type-check the path.
- let (pat_ty, def) = self.instantiate_value_path(segments, opt_ty, def, pat.span, pat.id);
+ let (pat_ty, def) = self.instantiate_value_path(segments, opt_ty, def, pat.span,
+ pat.hir_id);
if !pat_ty.is_fn() {
report_unexpected_def(def);
return self.tcx.types.err;
let field_ty = self.field_ty(subpat.span, &variant.fields[i], substs);
self.check_pat_walk(&subpat, field_ty, def_bm, match_arm_pat_span);
- self.tcx.check_stability(variant.fields[i].did, Some(pat.id), subpat.span);
+ self.tcx.check_stability(variant.fields[i].did, Some(pat.hir_id), subpat.span);
}
} else {
let subpats_ending = if subpats.len() == 1 { "" } else { "s" };
fn check_struct_pat_fields(&self,
adt_ty: Ty<'tcx>,
- pat_id: ast::NodeId,
+ pat_id: hir::HirId,
span: Span,
variant: &'tcx ty::VariantDef,
fields: &'gcx [Spanned<hir::FieldPat>],
vacant.insert(span);
field_map.get(&ident)
.map(|(i, f)| {
- self.write_field_index(field.id, *i);
+ self.write_field_index(field.hir_id, *i);
self.tcx.check_stability(f.did, Some(pat_id), span);
self.field_ty(span, f, substs)
})
if let &ty::Adt(adt_def, ..) = t {
if adt_def.is_enum() {
if let hir::ExprKind::Call(ref expr, _) = call_expr.node {
- unit_variant = Some(self.tcx.hir().node_to_pretty_string(expr.id))
+ unit_variant = Some(self.tcx.hir().hir_to_pretty_string(expr.hir_id))
}
}
}
} else {
("", lint::builtin::TRIVIAL_CASTS)
};
- let mut err = fcx.tcx.struct_span_lint_node(
+ let mut err = fcx.tcx.struct_span_lint_hir(
lint,
- self.expr.id,
+ self.expr.hir_id,
self.span,
&format!("trivial {}cast: `{}` as `{}`",
adjective,
self.cast_ty = fcx.structurally_resolved_type(self.span, self.cast_ty);
debug!("check_cast({}, {:?} as {:?})",
- self.expr.id,
+ self.expr.hir_id,
self.expr_ty,
self.cast_ty);
opt_kind, expected_sig
);
- let expr_def_id = self.tcx.hir().local_def_id(expr.id);
+ let expr_def_id = self.tcx.hir().local_def_id_from_hir_id(expr.hir_id);
let ClosureSignatures {
bound_sig,
let closure_type = self.tcx.mk_closure(expr_def_id, substs);
debug!(
- "check_closure: expr.id={:?} closure_type={:?}",
- expr.id, closure_type
+ "check_closure: expr.hir_id={:?} closure_type={:?}",
+ expr.hir_id, closure_type
);
// Tuple up the arguments and insert the resulting function type into
Expressions::UpFront(coercion_sites) => {
// if the user gave us an array to validate, check that we got
// the next expression in the list, as expected
- assert_eq!(coercion_sites[self.pushed].as_coercion_site().id, e.id);
+ assert_eq!(coercion_sites[self.pushed].as_coercion_site().hir_id,
+ e.hir_id);
}
}
self.pushed += 1;
db.span_label(cause.span, "return type is not `()`");
}
ObligationCauseCode::BlockTailExpression(blk_id) => {
- let parent_id = fcx.tcx.hir().get_parent_node(blk_id);
+ let parent_id = fcx.tcx.hir().get_parent_node_by_hir_id(blk_id);
db = self.report_return_mismatched_types(
cause,
expected,
found: Ty<'tcx>,
err: TypeError<'tcx>,
fcx: &FnCtxt<'a, 'gcx, 'tcx>,
- id: syntax::ast::NodeId,
- expression: Option<(&'gcx hir::Expr, syntax::ast::NodeId)>,
+ id: hir::HirId,
+ expression: Option<(&'gcx hir::Expr, hir::HirId)>,
) -> DiagnosticBuilder<'a> {
let mut db = fcx.report_mismatched_types(cause, expected, found, err);
// Verify that this is a tail expression of a function, otherwise the
// label pointing out the cause for the type coercion will be wrong
// as prior return coercions would not be relevant (#57664).
- let parent_id = fcx.tcx.hir().get_parent_node(id);
+ let parent_id = fcx.tcx.hir().get_parent_node_by_hir_id(id);
let fn_decl = if let Some((expr, blk_id)) = expression {
pointing_at_return_type = fcx.suggest_mismatched_types_on_tail(
&mut db,
cause.span,
blk_id,
);
- let parent = fcx.tcx.hir().get(parent_id);
+ let parent = fcx.tcx.hir().get_by_hir_id(parent_id);
fcx.get_node_fn_decl(parent).map(|(fn_decl, _, is_main)| (fn_decl, is_main))
} else {
fcx.get_fn_decl(parent_id)
use rustc::infer::InferOk;
use rustc::traits::{ObligationCause, ObligationCauseCode};
-use syntax::ast;
use syntax::util::parser::PREC_POSTFIX;
use syntax_pos::Span;
use rustc::hir;
probe::Mode::MethodCall,
expected,
checked_ty,
- ast::DUMMY_NODE_ID);
+ hir::DUMMY_HIR_ID);
methods.retain(|m| {
self.has_no_input_arg(m) &&
self.tcx.get_attrs(m.def_id).iter()
if let hir::def::Def::Local(id) = path.def {
let parent = self.tcx.hir().get_parent_node(id);
if let Some(Node::Expr(hir::Expr {
- id,
+ hir_id,
node: hir::ExprKind::Closure(_, decl, ..),
..
})) = self.tcx.hir().find(parent) {
- let parent = self.tcx.hir().get_parent_node(*id);
+ let parent = self.tcx.hir().get_parent_node_by_hir_id(*hir_id);
if let (Some(Node::Expr(hir::Expr {
node: hir::ExprKind::MethodCall(path, span, expr),
..
- })), 1) = (self.tcx.hir().find(parent), decl.inputs.len()) {
+ })), 1) = (self.tcx.hir().find_by_hir_id(parent), decl.inputs.len()) {
let self_ty = self.tables.borrow().node_type(expr[0].hir_id);
let self_ty = format!("{:?}", self_ty);
let name = path.ident.as_str();
checked_ty: Ty<'tcx>,
expected_ty: Ty<'tcx>,
) -> bool {
- let parent_id = self.tcx.hir().get_parent_node(expr.id);
- if let Some(parent) = self.tcx.hir().find(parent_id) {
+ let parent_id = self.tcx.hir().get_parent_node_by_hir_id(expr.hir_id);
+ if let Some(parent) = self.tcx.hir().find_by_hir_id(parent_id) {
// Shouldn't suggest `.into()` on `const`s.
if let Node::Item(Item { node: ItemKind::Const(_, _), .. }) = parent {
// FIXME(estebank): modify once we decide to suggest `as` casts
if let Some(hir::Node::Expr(hir::Expr {
node: hir::ExprKind::Struct(_, fields, _),
..
- })) = self.tcx.hir().find(self.tcx.hir().get_parent_node(expr.id)) {
+ })) = self.tcx.hir().find_by_hir_id(self.tcx.hir().get_parent_node_by_hir_id(expr.hir_id)) {
// `expr` is a literal field for a struct, only suggest if appropriate
for field in fields {
- if field.expr.id == expr.id && field.is_shorthand {
+ if field.expr.hir_id == expr.hir_id && field.is_shorthand {
// This is a field literal
prefix = format!("{}: ", field.ident);
break;
pub fn method_exists(&self,
method_name: ast::Ident,
self_ty: Ty<'tcx>,
- call_expr_id: ast::NodeId,
+ call_expr_id: hir::HirId,
allow_private: bool)
-> bool {
let mode = probe::Mode::MethodCall;
msg: &str,
method_name: ast::Ident,
self_ty: Ty<'tcx>,
- call_expr_id: ast::NodeId,
+ call_expr_id: hir::HirId,
) {
let has_params = self
.probe_for_name(
.unwrap().insert(import_def_id);
}
- self.tcx.check_stability(pick.item.def_id, Some(call_expr.id), span);
+ self.tcx.check_stability(pick.item.def_id, Some(call_expr.hir_id), span);
let result = self.confirm_method(
span,
let mode = probe::Mode::MethodCall;
let self_ty = self.resolve_type_vars_if_possible(&self_ty);
self.probe_for_name(span, mode, method_name, IsSuggestion(false),
- self_ty, call_expr.id, scope)
+ self_ty, call_expr.hir_id, scope)
}
/// `lookup_method_in_trait` is used for overloaded operators.
span: Span,
method_name: ast::Ident,
self_ty: Ty<'tcx>,
- expr_id: ast::NodeId
+ expr_id: hir::HirId
) -> Result<Def, MethodError<'tcx>> {
debug!(
"resolve_ufcs: method_name={:?} self_ty={:?} expr_id={:?}",
mode: Mode,
return_type: Ty<'tcx>,
self_ty: Ty<'tcx>,
- scope_expr_id: ast::NodeId)
+ scope_expr_id: hir::HirId)
-> Vec<ty::AssociatedItem> {
debug!("probe(self_ty={:?}, return_type={}, scope_expr_id={})",
self_ty,
item_name: ast::Ident,
is_suggestion: IsSuggestion,
self_ty: Ty<'tcx>,
- scope_expr_id: ast::NodeId,
+ scope_expr_id: hir::HirId,
scope: ProbeScope)
-> PickResult<'tcx> {
debug!("probe(self_ty={:?}, item_name={}, scope_expr_id={})",
return_type: Option<Ty<'tcx>>,
is_suggestion: IsSuggestion,
self_ty: Ty<'tcx>,
- scope_expr_id: ast::NodeId,
+ scope_expr_id: hir::HirId,
scope: ProbeScope,
op: OP)
-> Result<R, MethodError<'tcx>>
"the type of this value must be known \
to call a method on a raw pointer on it");
} else {
- self.tcx.lint_node(
+ self.tcx.lint_hir(
lint::builtin::TYVAR_BEHIND_RAW_POINTER,
scope_expr_id,
span,
}
fn assemble_extension_candidates_for_traits_in_scope(&mut self,
- expr_id: ast::NodeId)
+ expr_hir_id: hir::HirId)
-> Result<(), MethodError<'tcx>> {
- if expr_id == ast::DUMMY_NODE_ID {
+ if expr_hir_id == hir::DUMMY_HIR_ID {
return Ok(())
}
let mut duplicates = FxHashSet::default();
- let expr_hir_id = self.tcx.hir().node_to_hir_id(expr_id);
let opt_applicable_traits = self.tcx.in_scope_traits(expr_hir_id);
if let Some(applicable_traits) = opt_applicable_traits {
for trait_candidate in applicable_traits.iter() {
steps, IsSuggestion(true));
pcx.allow_similar_names = true;
pcx.assemble_inherent_candidates();
- pcx.assemble_extension_candidates_for_traits_in_scope(ast::DUMMY_NODE_ID)?;
+ pcx.assemble_extension_candidates_for_traits_in_scope(hir::DUMMY_HIR_ID)?;
let method_names = pcx.candidate_method_names();
pcx.allow_similar_names = false;
pcx.reset();
pcx.method_name = Some(method_name);
pcx.assemble_inherent_candidates();
- pcx.assemble_extension_candidates_for_traits_in_scope(ast::DUMMY_NODE_ID)
+ pcx.assemble_extension_candidates_for_traits_in_scope(hir::DUMMY_HIR_ID)
.ok().map_or(None, |_| {
pcx.pick_core()
.and_then(|pick| pick.ok())
use crate::lint;
use crate::util::captures::Captures;
use crate::util::common::{ErrorReported, indenter};
-use crate::util::nodemap::{DefIdMap, DefIdSet, FxHashMap, FxHashSet, NodeMap};
+use crate::util::nodemap::{DefIdMap, DefIdSet, FxHashMap, FxHashSet, HirIdMap, NodeMap};
pub use self::Expectation::*;
use self::autoderef::Autoderef;
pub struct EnclosingBreakables<'gcx: 'tcx, 'tcx> {
stack: Vec<BreakableCtxt<'gcx, 'tcx>>,
- by_id: NodeMap<usize>,
+ by_id: HirIdMap<usize>,
}
impl<'gcx, 'tcx> EnclosingBreakables<'gcx, 'tcx> {
- fn find_breakable(&mut self, target_id: ast::NodeId) -> &mut BreakableCtxt<'gcx, 'tcx> {
+ fn find_breakable(&mut self, target_id: hir::HirId) -> &mut BreakableCtxt<'gcx, 'tcx> {
let ix = *self.by_id.get(&target_id).unwrap_or_else(|| {
bug!("could not find enclosing breakable with id {}", target_id);
});
/// Produces warning on the given node, if the current point in the
/// function is unreachable, and there hasn't been another warning.
- fn warn_if_unreachable(&self, id: ast::NodeId, span: Span, kind: &str) {
+ fn warn_if_unreachable(&self, id: hir::HirId, span: Span, kind: &str) {
if self.diverges.get() == Diverges::Always {
self.diverges.set(Diverges::WarnedAlways);
debug!("warn_if_unreachable: id={:?} span={:?} kind={}", id, span, kind);
- self.tcx().lint_node(
+ self.tcx().lint_hir(
lint::builtin::UNREACHABLE_CODE,
id, span,
&format!("unreachable {}", kind));
}
}
- pub fn write_field_index(&self, node_id: ast::NodeId, index: usize) {
- let hir_id = self.tcx.hir().node_to_hir_id(node_id);
+ pub fn write_field_index(&self, hir_id: hir::HirId, index: usize) {
self.tables.borrow_mut().field_indices_mut().insert(hir_id, index);
}
// Closure arguments themselves can't be diverging, but
// a previous argument can, e.g., `foo(panic!(), || {})`.
if !check_closures {
- self.warn_if_unreachable(arg.id, arg.span, "expression");
+ self.warn_if_unreachable(arg.hir_id, arg.span, "expression");
}
let is_closure = match arg.node {
ret_coercion.borrow_mut()
.coerce(self,
&self.cause(return_expr.span,
- ObligationCauseCode::ReturnType(return_expr.id)),
+ ObligationCauseCode::ReturnType(return_expr.hir_id)),
return_expr,
return_expr_ty);
}
let field_ty = self.field_ty(expr.span, field, substs);
// Save the index of all fields regardless of their visibility in case
// of error recovery.
- self.write_field_index(expr.id, index);
+ self.write_field_index(expr.hir_id, index);
if field.vis.is_accessible_from(def_scope, self.tcx) {
let adjustments = autoderef.adjust_steps(self, needs);
self.apply_adjustments(base, adjustments);
autoderef.finalize(self);
- self.tcx.check_stability(field.did, Some(expr.id), expr.span);
+ self.tcx.check_stability(field.did, Some(expr.hir_id), expr.span);
return field_ty;
}
private_candidate = Some((base_def.did, field_ty));
self.apply_adjustments(base, adjustments);
autoderef.finalize(self);
- self.write_field_index(expr.id, index);
+ self.write_field_index(expr.hir_id, index);
return field_ty;
}
}
"field `{}` of struct `{}` is private",
field, struct_path);
// Also check if an accessible method exists, which is often what is meant.
- if self.method_exists(field, expr_t, expr.id, false) && !self.expr_in_place(expr.id) {
+ if self.method_exists(field, expr_t, expr.hir_id, false)
+ && !self.expr_in_place(expr.hir_id)
+ {
self.suggest_method_call(
&mut err,
&format!("a method `{}` also exists, call it with parentheses", field),
field,
expr_t,
- expr.id,
+ expr.hir_id,
);
}
err.emit();
field_ty
} else if field.name == keywords::Invalid.name() {
self.tcx().types.err
- } else if self.method_exists(field, expr_t, expr.id, true) {
+ } else if self.method_exists(field, expr_t, expr.hir_id, true) {
let mut err = type_error_struct!(self.tcx().sess, field.span, expr_t, E0615,
"attempted to take value of method `{}` on type `{}`",
field, expr_t);
- if !self.expr_in_place(expr.id) {
+ if !self.expr_in_place(expr.hir_id) {
self.suggest_method_call(
&mut err,
"use parentheses to call the method",
field,
expr_t,
- expr.id
+ expr.hir_id
);
} else {
err.help("methods are immutable and cannot be assigned to");
) {
let base = self.tcx.sess.source_map()
.span_to_snippet(base.span)
- .unwrap_or_else(|_| self.tcx.hir().node_to_pretty_string(base.id));
+ .unwrap_or_else(|_|
+ self.tcx.hir().hir_to_pretty_string(base.hir_id));
let help = "instead of using tuple indexing, use array indexing";
let suggestion = format!("{}[{}]", base, field);
let applicability = if len < user_index {
ty::RawPtr(..) => {
let base = self.tcx.sess.source_map()
.span_to_snippet(base.span)
- .unwrap_or_else(|_| self.tcx.hir().node_to_pretty_string(base.id));
+ .unwrap_or_else(|_| self.tcx.hir().hir_to_pretty_string(base.hir_id));
let msg = format!("`{}` is a raw pointer; try dereferencing it", base);
let suggestion = format!("(*{}).{}", base, field);
err.span_suggestion(
fn check_expr_struct_fields(&self,
adt_ty: Ty<'tcx>,
expected: Expectation<'tcx>,
- expr_id: ast::NodeId,
+ expr_id: hir::HirId,
span: Span,
variant: &'tcx ty::VariantDef,
ast_fields: &'gcx [hir::Field],
let ident = tcx.adjust_ident(field.ident, variant.did, self.body_id).0;
let field_type = if let Some((i, v_field)) = remaining_fields.remove(&ident) {
seen_fields.insert(ident, field.span);
- self.write_field_index(field.id, i);
+ self.write_field_index(field.hir_id, i);
// We don't look at stability attributes on
// struct-like enums (yet...), but it's definitely not
pub fn check_struct_path(&self,
qpath: &QPath,
- node_id: ast::NodeId)
+ hir_id: hir::HirId)
-> Option<(&'tcx ty::VariantDef, Ty<'tcx>)> {
let path_span = match *qpath {
QPath::Resolved(_, ref path) => path.span,
QPath::TypeRelative(ref qself, _) => qself.span
};
- let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, node_id);
+ let (def, ty) = self.finish_resolving_struct_path(qpath, path_span, hir_id);
let variant = match def {
Def::Err => {
self.set_tainted_by_errors();
if let Some((variant, did, substs)) = variant {
debug!("check_struct_path: did={:?} substs={:?}", did, substs);
- let hir_id = self.tcx.hir().node_to_hir_id(node_id);
self.write_user_type_annotation_from_substs(hir_id, did, substs, None);
// Check bounds on type arguments used in the path.
{
// Find the relevant variant
let (variant, adt_ty) =
- if let Some(variant_ty) = self.check_struct_path(qpath, expr.id) {
+ if let Some(variant_ty) = self.check_struct_path(qpath, expr.hir_id) {
variant_ty
} else {
self.check_struct_fields_on_error(fields, base_expr);
adt.variant_descr());
}
- let error_happened = self.check_expr_struct_fields(adt_ty, expected, expr.id, path_span,
+ let error_happened = self.check_expr_struct_fields(adt_ty, expected, expr.hir_id, path_span,
variant, fields, base_expr.is_none());
if let &Some(ref base_expr) = base_expr {
// If check_expr_struct_fields hit an error, do not attempt to populate
expr, expected);
// Warn for expressions after diverging siblings.
- self.warn_if_unreachable(expr.id, expr.span, "expression");
+ self.warn_if_unreachable(expr.hir_id, expr.span, "expression");
// Hide the outer diverging and has_errors flags.
let old_diverges = self.diverges.get();
ExprKind::Loop(..) | ExprKind::While(..) |
ExprKind::If(..) | ExprKind::Match(..) => {}
- _ => self.warn_if_unreachable(expr.id, expr.span, "expression")
+ _ => self.warn_if_unreachable(expr.hir_id, expr.span, "expression")
}
// Any expression that produces a value of type `!` must have diverged
self.diverges.set(self.diverges.get() | old_diverges);
self.has_errors.set(self.has_errors.get() | old_has_errors);
- debug!("type of {} is...", self.tcx.hir().node_to_string(expr.id));
+ debug!("type of {} is...", self.tcx.hir().hir_to_string(expr.hir_id));
debug!("... {:?}, expected is {:?}", ty, expected);
ty
);
let tcx = self.tcx;
- let id = expr.id;
+ let id = expr.hir_id;
match expr.node {
ExprKind::Box(ref subexpr) => {
let expected_inner = expected.to_option(self).map_or(NoExpectation, |ty| {
}
}
ExprKind::Path(ref qpath) => {
- let (def, opt_ty, segs) = self.resolve_ty_and_def_ufcs(qpath, expr.id, expr.span);
+ let (def, opt_ty, segs) = self.resolve_ty_and_def_ufcs(qpath, expr.hir_id,
+ expr.span);
let ty = match def {
Def::Err => {
self.set_tainted_by_errors();
}
ExprKind::Break(destination, ref expr_opt) => {
if let Ok(target_id) = destination.target_id {
+ let target_id = tcx.hir().node_to_hir_id(target_id);
let (e_ty, cause);
if let Some(ref e) = *expr_opt {
// If this is a break with a value, we need to type-check
*self.ret_coercion_span.borrow_mut() = Some(expr.span);
}
let cause = self.cause(expr.span, ObligationCauseCode::ReturnNoExpression);
- if let Some((fn_decl, _)) = self.get_fn_decl(expr.id) {
+ if let Some((fn_decl, _)) = self.get_fn_decl(expr.hir_id) {
coercion.coerce_forced_unit(
self,
&cause,
may_break: false, // Will get updated if/when we find a `break`.
};
- let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
+ let (ctxt, ()) = self.with_breakable_ctxt(expr.hir_id, ctxt, || {
self.check_expr_has_type_or_error(&cond, tcx.types.bool);
let cond_diverging = self.diverges.get();
self.check_block_no_value(&body);
may_break: false, // Will get updated if/when we find a `break`.
};
- let (ctxt, ()) = self.with_breakable_ctxt(expr.id, ctxt, || {
+ let (ctxt, ()) = self.with_breakable_ctxt(expr.hir_id, ctxt, || {
self.check_block_no_value(&body);
});
fn finish_resolving_struct_path(&self,
qpath: &QPath,
path_span: Span,
- node_id: ast::NodeId)
+ hir_id: hir::HirId)
-> (Def, Ty<'tcx>)
{
match *qpath {
} else {
Def::Err
};
- let hir_id = self.tcx.hir().node_to_hir_id(node_id);
let (ty, def) = AstConv::associated_path_to_ty(self, hir_id, path_span,
ty, def, segment, true);
// Write back the new resolution.
- let hir_id = self.tcx.hir().node_to_hir_id(node_id);
self.tables.borrow_mut().type_dependent_defs_mut().insert(hir_id, def);
(def, ty)
/// definition. The newly resolved definition is written into `type_dependent_defs`.
pub fn resolve_ty_and_def_ufcs<'b>(&self,
qpath: &'b QPath,
- node_id: ast::NodeId,
+ hir_id: hir::HirId,
span: Span)
-> (Def, Option<Ty<'tcx>>, &'b [hir::PathSegment])
{
- debug!("resolve_ty_and_def_ufcs: qpath={:?} node_id={:?} span={:?}", qpath, node_id, span);
+ debug!("resolve_ty_and_def_ufcs: qpath={:?} hir_id={:?} span={:?}", qpath, hir_id, span);
let (ty, qself, item_segment) = match *qpath {
QPath::Resolved(ref opt_qself, ref path) => {
return (path.def,
(self.to_ty(qself), qself, segment)
}
};
- let hir_id = self.tcx.hir().node_to_hir_id(node_id);
if let Some(cached_def) = self.tables.borrow().type_dependent_defs().get(hir_id) {
// Return directly on cache hit. This is useful to avoid doubly reporting
// errors with default match binding modes. See #44614.
return (*cached_def, Some(ty), slice::from_ref(&**item_segment))
}
let item_name = item_segment.ident;
- let def = match self.resolve_ufcs(span, item_name, ty, node_id) {
+ let def = match self.resolve_ufcs(span, item_name, ty, hir_id) {
Ok(def) => def,
Err(error) => {
let def = match error {
hir::StmtKind::Local(..) | hir::StmtKind::Expr(..) | hir::StmtKind::Semi(..) => {}
}
- self.warn_if_unreachable(stmt.id, stmt.span, "statement");
+ self.warn_if_unreachable(stmt.hir_id, stmt.span, "statement");
// Hide the outer diverging and `has_errors` flags.
let old_diverges = self.diverges.get();
may_break: false,
};
- let blk_node_id = self.tcx.hir().hir_to_node_id(blk.hir_id);
- let (ctxt, ()) = self.with_breakable_ctxt(blk_node_id, ctxt, || {
+ let (ctxt, ()) = self.with_breakable_ctxt(blk.hir_id, ctxt, || {
for s in &blk.stmts {
self.check_stmt(s);
}
let tail_expr_ty = tail_expr.map(|t| self.check_expr_with_expectation(t, expected));
let mut enclosing_breakables = self.enclosing_breakables.borrow_mut();
- let ctxt = enclosing_breakables.find_breakable(blk_node_id);
+ let ctxt = enclosing_breakables.find_breakable(blk.hir_id);
let coerce = ctxt.coerce.as_mut().unwrap();
if let Some(tail_expr_ty) = tail_expr_ty {
let tail_expr = tail_expr.unwrap();
let cause = self.cause(tail_expr.span,
- ObligationCauseCode::BlockTailExpression(blk_node_id));
+ ObligationCauseCode::BlockTailExpression(blk.hir_id));
coerce.coerce(self,
&cause,
tail_expr,
// that highlight errors inline.
let mut sp = blk.span;
let mut fn_span = None;
+ let blk_node_id = self.tcx.hir().hir_to_node_id(blk.hir_id);
if let Some((decl, ident)) = self.get_parent_fn_decl(blk_node_id) {
let ret_sp = decl.output.span();
if let Some(block_sp) = self.parent_item_span(blk_node_id) {
}
}
- /// Given a `NodeId`, return the `FnDecl` of the method it is enclosed by and whether a
+ /// Given a `HirId`, return the `FnDecl` of the method it is enclosed by and whether a
/// suggestion can be made, `None` otherwise.
- pub fn get_fn_decl(&self, blk_id: ast::NodeId) -> Option<(hir::FnDecl, bool)> {
+ pub fn get_fn_decl(&self, blk_id: hir::HirId) -> Option<(hir::FnDecl, bool)> {
// Get enclosing Fn, if it is a function or a trait method, unless there's a `loop` or
// `while` before reaching it, as block tail returns are not available in them.
self.tcx.hir().get_return_block(blk_id).and_then(|blk_id| {
- let parent = self.tcx.hir().get(blk_id);
+ let parent = self.tcx.hir().get_by_hir_id(blk_id);
self.get_node_fn_decl(parent).map(|(fn_decl, _, is_main)| (fn_decl, is_main))
})
}
expected: Ty<'tcx>,
found: Ty<'tcx>,
cause_span: Span,
- blk_id: ast::NodeId,
+ blk_id: hir::HirId,
) -> bool {
self.suggest_missing_semicolon(err, expression, expected, cause_span);
let mut pointing_at_return_type = false;
self_ty: Option<Ty<'tcx>>,
def: Def,
span: Span,
- node_id: ast::NodeId)
+ hir_id: hir::HirId)
-> (Ty<'tcx>, Def) {
debug!(
- "instantiate_value_path(segments={:?}, self_ty={:?}, def={:?}, node_id={})",
+ "instantiate_value_path(segments={:?}, self_ty={:?}, def={:?}, hir_id={})",
segments,
self_ty,
def,
- node_id,
+ hir_id,
);
let tcx = self.tcx;
Def::Local(nid) | Def::Upvar(nid, ..) => {
let ty = self.local_ty(span, nid).decl_ty;
let ty = self.normalize_associated_types_in(span, &ty);
- self.write_ty(tcx.hir().node_to_hir_id(node_id), ty);
+ self.write_ty(hir_id, ty);
return (ty, def);
}
_ => {}
assert!(!ty.has_escaping_bound_vars());
// First, store the "user substs" for later.
- let hir_id = tcx.hir().node_to_hir_id(node_id);
self.write_user_type_annotation_from_substs(hir_id, def_id, substs, user_self_ty);
// Add all the obligations that are required, substituting and
}
}
- self.check_rustc_args_require_const(def_id, node_id, span);
+ self.check_rustc_args_require_const(def_id, hir_id, span);
debug!("instantiate_value_path: type of {:?} is {:?}",
- node_id,
+ hir_id,
ty_substituted);
self.write_substs(hir_id, substs);
fn check_rustc_args_require_const(&self,
def_id: DefId,
- node_id: ast::NodeId,
+ hir_id: hir::HirId,
span: Span) {
// We're only interested in functions tagged with
// #[rustc_args_required_const], so ignore anything that's not.
// If our calling expression is indeed the function itself, we're good!
// If not, generate an error that this can only be called directly.
- if let Node::Expr(expr) = self.tcx.hir().get(self.tcx.hir().get_parent_node(node_id)) {
+ if let Node::Expr(expr) = self.tcx.hir().get_by_hir_id(
+ self.tcx.hir().get_parent_node_by_hir_id(hir_id))
+ {
if let ExprKind::Call(ref callee, ..) = expr.node {
- if callee.id == node_id {
+ if callee.hir_id == hir_id {
return
}
}
}
}
- fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: ast::NodeId,
+ fn with_breakable_ctxt<F: FnOnce() -> R, R>(&self, id: hir::HirId,
ctxt: BreakableCtxt<'gcx, 'tcx>, f: F)
-> (BreakableCtxt<'gcx, 'tcx>, R) {
let index;
}
/// Returns `true` if an expression is contained inside the LHS of an assignment expression.
- fn expr_in_place(&self, mut expr_id: ast::NodeId) -> bool {
+ fn expr_in_place(&self, mut expr_id: hir::HirId) -> bool {
let mut contained_in_place = false;
while let hir::Node::Expr(parent_expr) =
- self.tcx.hir().get(self.tcx.hir().get_parent_node(expr_id))
+ self.tcx.hir().get_by_hir_id(self.tcx.hir().get_parent_node_by_hir_id(expr_id))
{
match &parent_expr.node {
hir::ExprKind::Assign(lhs, ..) | hir::ExprKind::AssignOp(_, lhs, ..) => {
- if lhs.id == expr_id {
+ if lhs.hir_id == expr_id {
contained_in_place = true;
break;
}
}
_ => (),
}
- expr_id = parent_expr.id;
+ expr_id = parent_expr.hir_id;
}
contained_in_place
{
let tcx = self.tcx;
- debug!("check_binop(expr.id={}, expr={:?}, op={:?}, lhs_expr={:?}, rhs_expr={:?})",
- expr.id,
+ debug!("check_binop(expr.hir_id={}, expr={:?}, op={:?}, lhs_expr={:?}, rhs_expr={:?})",
+ expr.hir_id,
expr,
op,
lhs_expr,
is_assign: IsAssign)
-> (Ty<'tcx>, Ty<'tcx>, Ty<'tcx>)
{
- debug!("check_overloaded_binop(expr.id={}, op={:?}, is_assign={:?})",
- expr.id,
+ debug!("check_overloaded_binop(expr.hir_id={}, op={:?}, is_assign={:?})",
+ expr.hir_id,
op,
is_assign);
hir::ExprKind::Ret(Some(ref ret_expr)) => {
let call_site_scope = self.call_site_scope;
debug!(
- "visit_expr ExprKind::Ret ret_expr.id {} call_site_scope: {:?}",
- ret_expr.id, call_site_scope
+ "visit_expr ExprKind::Ret ret_expr.hir_id {} call_site_scope: {:?}",
+ ret_expr.hir_id, call_site_scope
);
let call_site_region = self.tcx.mk_region(ty::ReScope(call_site_scope.unwrap()));
self.type_of_node_must_outlive(
let body = self.fcx.tcx.hir().body(body_id);
self.visit_body(body);
self.fcx
- .analyze_closure(expr.id, expr.hir_id, expr.span, body, cc);
+ .analyze_closure(expr.hir_id, expr.span, body, cc);
}
intravisit::walk_expr(self, expr);
impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
fn analyze_closure(
&self,
- closure_node_id: ast::NodeId,
closure_hir_id: hir::HirId,
span: Span,
body: &hir::Body,
debug!(
"analyze_closure(id={:?}, body.id={:?})",
- closure_node_id,
+ closure_hir_id,
body.id()
);
span_bug!(
span,
"type of closure expr {:?} is not a closure {:?}",
- closure_node_id,
+ closure_hir_id,
t
);
}
None
};
+ let closure_node_id = self.tcx.hir().hir_to_node_id(closure_hir_id);
+
self.tcx.with_freevars(closure_node_id, |freevars| {
let mut freevar_list: Vec<ty::UpvarId> = Vec::with_capacity(freevars.len());
for freevar in freevars {
impl<'a, 'gcx, 'tcx> euv::Delegate<'tcx> for InferBorrowKind<'a, 'gcx, 'tcx> {
fn consume(
&mut self,
- _consume_id: ast::NodeId,
+ _consume_id: hir::HirId,
_consume_span: Span,
cmt: &mc::cmt_<'tcx>,
mode: euv::ConsumeMode,
fn borrow(
&mut self,
- borrow_id: ast::NodeId,
+ borrow_id: hir::HirId,
_borrow_span: Span,
cmt: &mc::cmt_<'tcx>,
_loan_region: ty::Region<'tcx>,
fn mutate(
&mut self,
- _assignment_id: ast::NodeId,
+ _assignment_id: hir::HirId,
_assignment_span: Span,
assignee_cmt: &mc::cmt_<'tcx>,
_mode: euv::MutateMode,
}
hir::ExprKind::Struct(_, ref fields, _) => {
for field in fields {
- self.visit_field_id(field.id);
+ self.visit_field_id(field.hir_id);
}
}
hir::ExprKind::Field(..) => {
- self.visit_field_id(e.id);
+ self.visit_field_id(e.hir_id);
}
_ => {}
}
}
hir::PatKind::Struct(_, ref fields, _) => {
for field in fields {
- self.visit_field_id(field.node.id);
+ self.visit_field_id(field.node.hir_id);
}
}
_ => {}
}
}
- fn visit_field_id(&mut self, node_id: ast::NodeId) {
- let hir_id = self.tcx().hir().node_to_hir_id(node_id);
+ fn visit_field_id(&mut self, hir_id: hir::HirId) {
if let Some(index) = self.fcx
.tables
.borrow_mut()
fn visit_expr(&mut self, expr: &'tcx hir::Expr) {
if let hir::ExprKind::Closure(..) = expr.node {
- let def_id = self.tcx.hir().local_def_id(expr.id);
+ let def_id = self.tcx.hir().local_def_id_from_hir_id(expr.hir_id);
self.tcx.generics_of(def_id);
self.tcx.type_of(def_id);
}
projects / rust.git / commitdiff