bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

hir: remove NodeId from Pat and FieldPat

Browse source
This commit is contained in:
ljedrz 2019-03-01 09:31:58 +01:00
parent 77fa041fc1
commit 50b8bc8c8c
17 changed files with 87 additions and 102 deletions
Download patch file Download diff file Expand all files Collapse all files

47
src/librustc/hir/lowering.rs
View file

@ -3740,12 +3740,11 @@ impl<'a> LoweringContext<'a> {
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),
@ -3777,9 +3776,8 @@ impl<'a> LoweringContext<'a> {
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,
@ -4353,7 +4351,7 @@ impl<'a> LoweringContext<'a> {
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,
@ -4362,9 +4360,9 @@ impl<'a> LoweringContext<'a> {
// `::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),
@ -4383,7 +4381,7 @@ impl<'a> LoweringContext<'a> {
};
// `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
@ -4391,7 +4389,7 @@ impl<'a> LoweringContext<'a> {
// `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()));
@ -4415,7 +4413,7 @@ impl<'a> LoweringContext<'a> {
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(
@ -4542,11 +4540,11 @@ impl<'a> LoweringContext<'a> {
// `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);
@ -4558,12 +4556,12 @@ impl<'a> LoweringContext<'a> {
// 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])
};
@ -4911,15 +4909,15 @@ impl<'a> LoweringContext<'a> {
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,
)
}
@ -4977,7 +4975,7 @@ impl<'a> LoweringContext<'a> {
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)
}
@ -4986,15 +4984,17 @@ impl<'a> LoweringContext<'a> {
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,
})
}),
node_id
)
}
fn pat_wild(&mut self, span: Span) -> P<hir::Pat> {
@ -5002,9 +5002,8 @@ impl<'a> LoweringContext<'a> {
}
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,

4
src/librustc/hir/mod.rs
View file

@ -834,7 +834,6 @@ pub struct Block {
#[derive(Clone, RustcEncodable, RustcDecodable)]
pub struct Pat {
pub id: NodeId,
pub hir_id: HirId,
pub node: PatKind,
pub span: Span,
@ -842,7 +841,7 @@ pub struct Pat {
impl fmt::Debug for Pat {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "pat({}: {})", self.id,
write!(f, "pat({}: {})", self.hir_id,
print::to_string(print::NO_ANN, |s| s.print_pat(self)))
}
}
@ -897,7 +896,6 @@ impl Pat {
/// except `is_shorthand` is true.
#[derive(Clone, RustcEncodable, RustcDecodable, Debug)]
pub struct FieldPat {
pub id: NodeId,
pub hir_id: HirId,
/// The identifier for the field.
pub ident: Ident,

2
src/librustc/ich/impls_hir.rs
View file

@ -421,7 +421,6 @@ impl_stable_hash_for!(struct hir::Block {
});
impl_stable_hash_for!(struct hir::Pat {
id -> _,
hir_id -> _,
node,
span,
@ -430,7 +429,6 @@ impl_stable_hash_for!(struct hir::Pat {
impl_stable_hash_for_spanned!(hir::FieldPat);
impl_stable_hash_for!(struct hir::FieldPat {
id -> _,
hir_id -> _,
ident -> (ident.name),
pat,

6
src/librustc/middle/expr_use_visitor.rs
View file

@ -19,7 +19,6 @@ use crate::ty::{self, TyCtxt, adjustment};
use crate::hir::{self, PatKind};
use rustc_data_structures::sync::Lrc;
use std::rc::Rc;
use syntax::ast;
use syntax::ptr::P;
use syntax_pos::Span;
use crate::util::nodemap::ItemLocalSet;
@ -74,7 +73,7 @@ pub trait Delegate<'tcx> {
// The local variable `id` is declared but not initialized.
fn decl_without_init(&mut self,
id: ast::NodeId,
id: hir::HirId,
span: Span);
// The path at `cmt` is being assigned to.
@ -609,8 +608,7 @@ impl<'a, 'gcx, 'tcx> ExprUseVisitor<'a, 'gcx, 'tcx> {
match local.init {
None => {
local.pat.each_binding(|_, hir_id, span, _| {
let node_id = self.mc.tcx.hir().hir_to_node_id(hir_id);
self.delegate.decl_without_init(node_id, span);
self.delegate.decl_without_init(hir_id, span);
})
}

18
src/librustc/middle/mem_categorization.rs
View file

@ -88,7 +88,7 @@ pub enum Categorization<'tcx> {
ThreadLocal(ty::Region<'tcx>), // value that cannot move, but still restricted in scope
StaticItem,
Upvar(Upvar), // upvar referenced by closure env
Local(ast::NodeId), // local variable
Local(hir::HirId), // local variable
Deref(cmt<'tcx>, PointerKind<'tcx>), // deref of a ptr
Interior(cmt<'tcx>, InteriorKind), // something interior: field, tuple, etc
Downcast(cmt<'tcx>, DefId), // selects a particular enum variant (*1)
@ -198,9 +198,9 @@ pub struct cmt_<'tcx> {
pub type cmt<'tcx> = Rc<cmt_<'tcx>>;
pub enum ImmutabilityBlame<'tcx> {
ImmLocal(ast::NodeId),
ImmLocal(hir::HirId),
ClosureEnv(LocalDefId),
LocalDeref(ast::NodeId),
LocalDeref(hir::HirId),
AdtFieldDeref(&'tcx ty::AdtDef, &'tcx ty::FieldDef)
}
@ -230,8 +230,8 @@ impl<'tcx> cmt_<'tcx> {
Categorization::Deref(ref base_cmt, BorrowedPtr(ty::ImmBorrow, _)) => {
// try to figure out where the immutable reference came from
match base_cmt.cat {
Categorization::Local(node_id) =>
Some(ImmutabilityBlame::LocalDeref(node_id)),
Categorization::Local(hir_id) =>
Some(ImmutabilityBlame::LocalDeref(hir_id)),
Categorization::Interior(ref base_cmt, InteriorField(field_index)) => {
base_cmt.resolve_field(field_index.0).map(|(adt_def, field_def)| {
ImmutabilityBlame::AdtFieldDeref(adt_def, field_def)
@ -247,8 +247,8 @@ impl<'tcx> cmt_<'tcx> {
_ => None
}
}
Categorization::Local(node_id) => {
Some(ImmutabilityBlame::ImmLocal(node_id))
Categorization::Local(hir_id) => {
Some(ImmutabilityBlame::ImmLocal(hir_id))
}
Categorization::Rvalue(..) |
Categorization::Upvar(..) |
@ -741,7 +741,7 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
Ok(cmt_ {
hir_id,
span,
cat: Categorization::Local(vid),
cat: Categorization::Local(self.tcx.hir().node_to_hir_id(vid)),
mutbl: MutabilityCategory::from_local(self.tcx, self.tables, vid),
ty: expr_ty,
note: NoteNone
@ -1495,7 +1495,7 @@ impl<'tcx> cmt_<'tcx> {
"non-place".into()
}
Categorization::Local(vid) => {
if tcx.hir().is_argument(vid) {
if tcx.hir().is_argument(tcx.hir().hir_to_node_id(vid)) {
"argument"
} else {
"local variable"

2
src/librustc/middle/resolve_lifetime.rs
View file

@ -2397,7 +2397,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> {
let help_name = if let Some(body) = parent {
let arg = &self.tcx.hir().body(body).arguments[index];
format!("`{}`", self.tcx.hir().node_to_pretty_string(arg.pat.id))
format!("`{}`", self.tcx.hir().hir_to_pretty_string(arg.pat.hir_id))
} else {
format!("argument {}", index + 1)
};

6
src/librustc_borrowck/borrowck/check_loans.rs
View file

@ -17,7 +17,6 @@ use rustc::middle::mem_categorization as mc;
use rustc::middle::mem_categorization::Categorization;
use rustc::middle::region;
use rustc::ty::{self, TyCtxt, RegionKind};
use syntax::ast;
use syntax_pos::Span;
use rustc::hir;
use rustc::hir::Node;
@ -177,7 +176,7 @@ impl<'a, 'tcx> euv::Delegate<'tcx> for CheckLoanCtxt<'a, 'tcx> {
self.check_assignment(assignment_id.local_id, assignment_span, assignee_cmt);
}
fn decl_without_init(&mut self, _id: ast::NodeId, _span: Span) { }
fn decl_without_init(&mut self, _id: hir::HirId, _span: Span) { }
}
pub fn check_loans<'a, 'b, 'c, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>,
@ -887,11 +886,10 @@ impl<'a, 'tcx> CheckLoanCtxt<'a, 'tcx> {
// Check for reassignments to (immutable) local variables. This
// needs to be done here instead of in check_loans because we
// depend on move data.
if let Categorization::Local(local_id) = assignee_cmt.cat {
if let Categorization::Local(hir_id) = assignee_cmt.cat {
let lp = opt_loan_path(assignee_cmt).unwrap();
self.move_data.each_assignment_of(assignment_id, &lp, |assign| {
if assignee_cmt.mutbl.is_mutable() {
let hir_id = self.bccx.tcx.hir().node_to_hir_id(local_id);
self.bccx.used_mut_nodes.borrow_mut().insert(hir_id);
} else {
self.bccx.report_reassigned_immutable_variable(

10
src/librustc_borrowck/borrowck/gather_loans/gather_moves.rs
View file

@ -11,7 +11,6 @@ use rustc::middle::mem_categorization::InteriorOffsetKind as Kind;
use rustc::ty::{self, Ty};
use std::rc::Rc;
use syntax::ast;
use syntax_pos::Span;
use rustc::hir::*;
use rustc::hir::Node;
@ -48,9 +47,9 @@ pub enum PatternSource<'tcx> {
/// with a reference to the let
fn get_pattern_source<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, pat: &Pat) -> PatternSource<'tcx> {
let parent = tcx.hir().get_parent_node(pat.id);
let parent = tcx.hir().get_parent_node_by_hir_id(pat.hir_id);
match tcx.hir().get(parent) {
match tcx.hir().get_by_hir_id(parent) {
Node::Expr(ref e) => {
// the enclosing expression must be a `match` or something else
assert!(match e.node {
@ -67,11 +66,10 @@ fn get_pattern_source<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, pat: &Pat) -> Patte
pub fn gather_decl<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>,
move_data: &MoveData<'tcx>,
var_id: ast::NodeId,
var_id: hir::HirId,
var_ty: Ty<'tcx>) {
let loan_path = Rc::new(LoanPath::new(LpVar(var_id), var_ty));
let hir_id = bccx.tcx.hir().node_to_hir_id(var_id);
move_data.add_move(bccx.tcx, loan_path, hir_id.local_id, Declared);
move_data.add_move(bccx.tcx, loan_path, var_id.local_id, Declared);
}
pub fn gather_move_from_expr<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>,

3
src/librustc_borrowck/borrowck/gather_loans/lifetime.rs
View file

@ -104,8 +104,7 @@ impl<'a, 'tcx> GuaranteeLifetimeContext<'a, 'tcx> {
Categorization::Upvar(..) => {
self.bccx.tcx.mk_region(ty::ReScope(self.item_scope))
}
Categorization::Local(local_id) => {
let hir_id = self.bccx.tcx.hir().node_to_hir_id(local_id);
Categorization::Local(hir_id) => {
self.bccx.tcx.mk_region(ty::ReScope(
self.bccx.region_scope_tree.var_scope(hir_id.local_id)))
}

7
src/librustc_borrowck/borrowck/gather_loans/mod.rs
View file

@ -147,10 +147,10 @@ impl<'a, 'tcx> euv::Delegate<'tcx> for GatherLoanCtxt<'a, 'tcx> {
assignee_cmt);
}
fn decl_without_init(&mut self, id: ast::NodeId, _span: Span) {
fn decl_without_init(&mut self, id: hir::HirId, _span: Span) {
let ty = self.bccx
.tables
.node_type(self.bccx.tcx.hir().node_to_hir_id(id));
.node_type(id);
gather_moves::gather_decl(self.bccx, &self.move_data, id, ty);
}
}
@ -438,9 +438,8 @@ impl<'a, 'tcx> GatherLoanCtxt<'a, 'tcx> {
while let Some(current_path) = wrapped_path {
wrapped_path = match current_path.kind {
LpVar(local_id) => {
LpVar(hir_id) => {
if !through_borrow {
let hir_id = self.bccx.tcx.hir().node_to_hir_id(local_id);
self.bccx.used_mut_nodes.borrow_mut().insert(hir_id);
}
None

57
src/librustc_borrowck/borrowck/mod.rs
View file

@ -335,7 +335,7 @@ impl<'tcx> Hash for LoanPath<'tcx> {
#[derive(PartialEq, Eq, Hash, Debug)]
pub enum LoanPathKind<'tcx> {
LpVar(ast::NodeId), // `x` in README.md
LpVar(hir::HirId), // `x` in README.md
LpUpvar(ty::UpvarId), // `x` captured by-value into closure
LpDowncast(Rc<LoanPath<'tcx>>, DefId), // `x` downcast to particular enum variant
LpExtend(Rc<LoanPath<'tcx>>, mc::MutabilityCategory, LoanPathElem<'tcx>)
@ -417,8 +417,7 @@ fn closure_to_block(closure_id: LocalDefId,
impl<'a, 'tcx> LoanPath<'tcx> {
pub fn kill_scope(&self, bccx: &BorrowckCtxt<'a, 'tcx>) -> region::Scope {
match self.kind {
LpVar(local_id) => {
let hir_id = bccx.tcx.hir().node_to_hir_id(local_id);
LpVar(hir_id) => {
bccx.region_scope_tree.var_scope(hir_id.local_id)
}
LpUpvar(upvar_id) => {
@ -919,7 +918,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
self.note_immutability_blame(
&mut db,
err.cmt.immutability_blame(),
self.tcx.hir().hir_to_node_id(err.cmt.hir_id)
err.cmt.hir_id
);
db.emit();
self.signal_error();
@ -1135,7 +1134,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
self.note_immutability_blame(
&mut err,
blame,
self.tcx.hir().hir_to_node_id(cmt.hir_id)
cmt.hir_id
);
if is_closure {
@ -1175,8 +1174,8 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
}
}
fn local_binding_mode(&self, node_id: ast::NodeId) -> ty::BindingMode {
let pat = match self.tcx.hir().get(node_id) {
fn local_binding_mode(&self, hir_id: hir::HirId) -> ty::BindingMode {
let pat = match self.tcx.hir().get_by_hir_id(hir_id) {
Node::Binding(pat) => pat,
node => bug!("bad node for local: {:?}", node)
};
@ -1192,16 +1191,16 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
}
}
fn local_ty(&self, node_id: ast::NodeId) -> (Option<&hir::Ty>, bool) {
let parent = self.tcx.hir().get_parent_node(node_id);
let parent_node = self.tcx.hir().get(parent);
fn local_ty(&self, hir_id: hir::HirId) -> (Option<&hir::Ty>, bool) {
let parent = self.tcx.hir().get_parent_node_by_hir_id(hir_id);
let parent_node = self.tcx.hir().get_by_hir_id(parent);
// The parent node is like a fn
if let Some(fn_like) = FnLikeNode::from_node(parent_node) {
// `nid`'s parent's `Body`
let fn_body = self.tcx.hir().body(fn_like.body());
// Get the position of `node_id` in the arguments list
let arg_pos = fn_body.arguments.iter().position(|arg| arg.pat.id == node_id);
let arg_pos = fn_body.arguments.iter().position(|arg| arg.pat.hir_id == hir_id);
if let Some(i) = arg_pos {
// The argument's `Ty`
(Some(&fn_like.decl().inputs[i]),
@ -1217,17 +1216,17 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
fn note_immutability_blame(&self,
db: &mut DiagnosticBuilder<'_>,
blame: Option<ImmutabilityBlame<'_>>,
error_node_id: ast::NodeId) {
error_hir_id: hir::HirId) {
match blame {
None => {}
Some(ImmutabilityBlame::ClosureEnv(_)) => {}
Some(ImmutabilityBlame::ImmLocal(node_id)) => {
self.note_immutable_local(db, error_node_id, node_id)
Some(ImmutabilityBlame::ImmLocal(hir_id)) => {
self.note_immutable_local(db, error_hir_id, hir_id)
}
Some(ImmutabilityBlame::LocalDeref(node_id)) => {
match self.local_binding_mode(node_id) {
Some(ImmutabilityBlame::LocalDeref(hir_id)) => {
match self.local_binding_mode(hir_id) {
ty::BindByReference(..) => {
let let_span = self.tcx.hir().span(node_id);
let let_span = self.tcx.hir().span_by_hir_id(hir_id);
let suggestion = suggest_ref_mut(self.tcx, let_span);
if let Some(replace_str) = suggestion {
db.span_suggestion(
@ -1244,7 +1243,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
}
}
ty::BindByValue(..) => {
if let (Some(local_ty), is_implicit_self) = self.local_ty(node_id) {
if let (Some(local_ty), is_implicit_self) = self.local_ty(hir_id) {
if let Some(msg) =
self.suggest_mut_for_immutable(local_ty, is_implicit_self) {
db.span_label(local_ty.span, msg);
@ -1273,12 +1272,12 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
// not a mutable reference) or to avoid borrowing altogether
fn note_immutable_local(&self,
db: &mut DiagnosticBuilder<'_>,
borrowed_node_id: ast::NodeId,
binding_node_id: ast::NodeId) {
let let_span = self.tcx.hir().span(binding_node_id);
if let ty::BindByValue(..) = self.local_binding_mode(binding_node_id) {
borrowed_hir_id: hir::HirId,
binding_hir_id: hir::HirId) {
let let_span = self.tcx.hir().span_by_hir_id(binding_hir_id);
if let ty::BindByValue(..) = self.local_binding_mode(binding_hir_id) {
if let Ok(snippet) = self.tcx.sess.source_map().span_to_snippet(let_span) {
let (ty, is_implicit_self) = self.local_ty(binding_node_id);
let (ty, is_implicit_self) = self.local_ty(binding_hir_id);
if is_implicit_self && snippet != "self" {
// avoid suggesting `mut &self`.
return
@ -1291,9 +1290,9 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
},
)) = ty.map(|t| &t.node)
{
let borrow_expr_id = self.tcx.hir().get_parent_node(borrowed_node_id);
let borrow_expr_id = self.tcx.hir().get_parent_node_by_hir_id(borrowed_hir_id);
db.span_suggestion(
self.tcx.hir().span(borrow_expr_id),
self.tcx.hir().span_by_hir_id(borrow_expr_id),
"consider removing the `&mut`, as it is an \
immutable binding to a mutable reference",
snippet,
@ -1373,7 +1372,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
if let Categorization::Deref(..) = err.cmt.cat {
db.span_label(*error_span, "cannot borrow as mutable");
} else if let Categorization::Local(local_id) = err.cmt.cat {
let span = self.tcx.hir().span(local_id);
let span = self.tcx.hir().span_by_hir_id(local_id);
if let Ok(snippet) = self.tcx.sess.source_map().span_to_snippet(span) {
if snippet.starts_with("ref mut ") || snippet.starts_with("&mut ") {
db.span_label(*error_span, "cannot reborrow mutably");
@ -1401,7 +1400,7 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
out.push_str(&self.tcx.hir().name_by_hir_id(id).as_str());
}
LpVar(id) => {
out.push_str(&self.tcx.hir().name(id).as_str());
out.push_str(&self.tcx.hir().name_by_hir_id(id).as_str());
}
LpDowncast(ref lp_base, variant_def_id) => {
@ -1512,7 +1511,7 @@ impl<'tcx> fmt::Debug for LoanPath<'tcx> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self.kind {
LpVar(id) => {
write!(f, "$({})", ty::tls::with(|tcx| tcx.hir().node_to_string(id)))
write!(f, "$({})", ty::tls::with(|tcx| tcx.hir().hir_to_string(id)))
}
LpUpvar(ty::UpvarId{ var_path: ty::UpvarPath {hir_id: var_id}, closure_expr_id }) => {
@ -1547,7 +1546,7 @@ impl<'tcx> fmt::Display for LoanPath<'tcx> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self.kind {
LpVar(id) => {
write!(f, "$({})", ty::tls::with(|tcx| tcx.hir().node_to_user_string(id)))
write!(f, "$({})", ty::tls::with(|tcx| tcx.hir().hir_to_user_string(id)))
}
LpUpvar(ty::UpvarId{ var_path: ty::UpvarPath { hir_id }, closure_expr_id: _ }) => {

4
src/librustc_driver/pretty.rs
View file

@ -428,8 +428,8 @@ impl<'hir> pprust_hir::PpAnn for IdentifiedAnnotation<'hir> {
}
pprust_hir::AnnNode::Pat(pat) => {
s.s.space()?;
s.synth_comment(format!("pat node_id: {} hir local_id: {}",
pat.id, pat.hir_id.local_id.as_u32()))
s.synth_comment(format!("pat hir_id: {} hir local_id: {}",
pat.hir_id, pat.hir_id.local_id.as_u32()))
}
}
}

2
src/librustc_mir/hair/cx/mod.rs
View file

@ -153,7 +153,7 @@ impl<'a, 'gcx, 'tcx> Cx<'a, 'gcx, 'tcx> {
pub fn pattern_from_hir(&mut self, p: &hir::Pat) -> Pattern<'tcx> {
let tcx = self.tcx.global_tcx();
let p = match tcx.hir().get(p.id) {
let p = match tcx.hir().get_by_hir_id(p.hir_id) {
Node::Pat(p) | Node::Binding(p) => p,
node => bug!("pattern became {:?}", node)
};

5
src/librustc_mir/hair/pattern/check_match.rs
View file

@ -24,7 +24,6 @@ use rustc::hir::{self, Pat, PatKind};
use smallvec::smallvec;
use std::slice;
use syntax::ast;
use syntax::ptr::P;
use syntax_pos::{Span, DUMMY_SP, MultiSpan};
@ -241,7 +240,7 @@ impl<'a, 'tcx> MatchVisitor<'a, 'tcx> {
}
fn check_irrefutable(&self, pat: &'tcx Pat, origin: &str) {
let module = self.tcx.hir().get_module_parent(pat.id);
let module = self.tcx.hir().get_module_parent_by_hir_id(pat.hir_id);
MatchCheckCtxt::create_and_enter(self.tcx, self.param_env, module, |ref mut cx| {
let mut patcx = PatternContext::new(self.tcx,
self.param_env.and(self.identity_substs),
@ -586,7 +585,7 @@ impl<'a, 'tcx> Delegate<'tcx> for MutationChecker<'a, 'tcx> {
ty::ImmBorrow | ty::UniqueImmBorrow => {}
}
}
fn decl_without_init(&mut self, _: ast::NodeId, _: Span) {}
fn decl_without_init(&mut self, _: hir::HirId, _: Span) {}
fn mutate(&mut self, _: hir::HirId, span: Span, _: &cmt_<'_>, mode: MutateMode) {
match mode {
MutateMode::JustWrite | MutateMode::WriteAndRead => {

3
src/librustc_passes/rvalue_promotion.rs
View file

@ -26,7 +26,6 @@ use rustc::ty::subst::{InternalSubsts, SubstsRef};
use rustc::util::nodemap::{ItemLocalSet, HirIdSet};
use rustc::hir;
use rustc_data_structures::sync::Lrc;
use syntax::ast;
use syntax_pos::{Span, DUMMY_SP};
use log::debug;
use Promotability::*;
@ -677,7 +676,7 @@ impl<'a, 'gcx, 'tcx> euv::Delegate<'tcx> for CheckCrateVisitor<'a, 'gcx> {
}
}
fn decl_without_init(&mut self, _id: ast::NodeId, _span: Span) {}
fn decl_without_init(&mut self, _id: hir::HirId, _span: Span) {}
fn mutate(&mut self,
_assignment_id: hir::HirId,
_assignment_span: Span,

3
src/librustc_typeck/check/mod.rs
View file

@ -1008,9 +1008,10 @@ impl<'a, 'gcx, 'tcx> Visitor<'gcx> for GatherLocalsVisitor<'a, 'gcx, 'tcx> {
if let PatKind::Binding(_, _, _, ident, _) = p.node {
let var_ty = self.assign(p.span, p.hir_id, None);
let node_id = self.fcx.tcx.hir().hir_to_node_id(p.hir_id);
if !self.fcx.tcx.features().unsized_locals {
self.fcx.require_type_is_sized(var_ty, p.span,
traits::VariableType(p.id));
traits::VariableType(node_id));
}
debug!("Pattern binding {} is assigned to {} with type {:?}",

2
src/librustc_typeck/check/upvar.rs
View file

@ -635,7 +635,7 @@ impl<'a, 'gcx, 'tcx> euv::Delegate<'tcx> for InferBorrowKind<'a, 'gcx, 'tcx> {
}
}
fn decl_without_init(&mut self, _id: ast::NodeId, _span: Span) {}
fn decl_without_init(&mut self, _id: hir::HirId, _span: Span) {}
fn mutate(
&mut self,