nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2025-02-05 19:43:24 +00:00
Code Issues Packages Projects Releases Wiki Activity

Use DefIndex instead of NodeId in UpvarId.

Browse Source
This commit is contained in:
Michael Woerister 2017-08-08 14:34:37 +02:00
parent a8cf6cc6db
commit 4dcc3a4aae
13 changed files with 142 additions and 85 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
src/librustc/ich/impls_ty.rs
View File

@ -11,6 +11,7 @@
//! This module contains `HashStable` implementations for various data types
//! from rustc::ty in no particular order.
use hir::def_id::DefId;
use ich::{self, StableHashingContext, NodeIdHashingMode};
use rustc_data_structures::stable_hasher::{HashStable, StableHasher,
StableHasherResult};
@ -618,7 +619,7 @@ for ty::TypeckTables<'gcx> {
hcx: &mut StableHashingContext<'a, 'gcx, 'tcx>,
hasher: &mut StableHasher<W>) {
let ty::TypeckTables {
local_id_root: _,
local_id_root,
ref type_dependent_defs,
ref node_types,
ref node_substs,
@ -649,8 +650,14 @@ for ty::TypeckTables<'gcx> {
closure_expr_id
} = *up_var_id;
let var_def_id = hcx.tcx().hir.local_def_id(var_id);
let closure_def_id = hcx.tcx().hir.local_def_id(closure_expr_id);
let var_def_id = DefId {
krate: local_id_root.krate,
index: var_id,
};
let closure_def_id = DefId {
krate: local_id_root.krate,
index: closure_expr_id,
};
(hcx.def_path_hash(var_def_id), hcx.def_path_hash(closure_def_id))
});

2
src/librustc/infer/error_reporting/mod.rs
View File

@ -913,7 +913,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
}
infer::UpvarRegion(ref upvar_id, _) => {
format!(" for capture of `{}` by closure",
self.tcx.local_var_name_str(upvar_id.var_id).to_string())
self.tcx.local_var_name_str_def_index(upvar_id.var_id))
}
};

12
src/librustc/infer/error_reporting/note.rs
View File

@ -45,8 +45,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
err.span_note(span,
&format!("...so that closure can access `{}`",
self.tcx
.local_var_name_str(upvar_id.var_id)
.to_string()));
.local_var_name_str_def_index(upvar_id.var_id)));
}
infer::InfStackClosure(span) => {
err.span_note(span, "...so that closure does not outlive its stack frame");
@ -176,16 +175,17 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> {
E0313,
"lifetime of borrowed pointer outlives lifetime \
of captured variable `{}`...",
self.tcx.local_var_name_str(upvar_id.var_id));
self.tcx
.local_var_name_str_def_index(upvar_id.var_id));
self.tcx.note_and_explain_region(&mut err,
"...the borrowed pointer is valid for ",
sub,
"...");
self.tcx
.note_and_explain_region(&mut err,
.note_and_explain_region(
&mut err,
&format!("...but `{}` is only valid for ",
self.tcx
.local_var_name_str(upvar_id.var_id)),
self.tcx.local_var_name_str_def_index(upvar_id.var_id)),
sup,
"");
err

11
src/librustc/middle/expr_use_visitor.rs
View File

@ -890,10 +890,13 @@ impl<'a, 'gcx, 'tcx> ExprUseVisitor<'a, 'gcx, 'tcx> {
self.tcx().with_freevars(closure_expr.id, |freevars| {
for freevar in freevars {
let def_id = freevar.def.def_id();
let id_var = self.tcx().hir.as_local_node_id(def_id).unwrap();
let upvar_id = ty::UpvarId { var_id: id_var,
closure_expr_id: closure_expr.id };
let var_def_id = freevar.def.def_id();
debug_assert!(var_def_id.is_local());
let closure_def_id = self.tcx().hir.local_def_id(closure_expr.id);
let upvar_id = ty::UpvarId {
var_id: var_def_id.index,
closure_expr_id: closure_def_id.index
};
let upvar_capture = self.mc.tables.upvar_capture(upvar_id);
let cmt_var = return_if_err!(self.cat_captured_var(closure_expr.id,
fn_decl_span,

17
src/librustc/middle/mem_categorization.rs
View File

@ -70,7 +70,7 @@ pub use self::Note::*;
use self::Aliasability::*;
use middle::region::RegionMaps;
use hir::def_id::DefId;
use hir::def_id::{DefId, DefIndex};
use hir::map as hir_map;
use infer::InferCtxt;
use hir::def::{Def, CtorKind};
@ -190,7 +190,7 @@ pub type cmt<'tcx> = Rc<cmt_<'tcx>>;
pub enum ImmutabilityBlame<'tcx> {
ImmLocal(ast::NodeId),
ClosureEnv(ast::NodeId),
ClosureEnv(DefIndex),
LocalDeref(ast::NodeId),
AdtFieldDeref(&'tcx ty::AdtDef, &'tcx ty::FieldDef)
}
@ -728,8 +728,13 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
None => span_bug!(span, "missing closure kind")
};
let upvar_id = ty::UpvarId { var_id,
closure_expr_id: fn_node_id };
let closure_expr_def_index = self.tcx.hir.local_def_id(fn_node_id).index;
let var_def_index = self.tcx.hir.local_def_id(var_id).index;
let upvar_id = ty::UpvarId {
var_id: var_def_index,
closure_expr_id: closure_expr_def_index
};
let var_hir_id = self.tcx.hir.node_to_hir_id(var_id);
let var_ty = self.node_ty(var_hir_id)?;
@ -766,8 +771,6 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
// If this is a by-ref capture, then the upvar we loaded is
// actually a reference, so we have to add an implicit deref
// for that.
let upvar_id = ty::UpvarId { var_id,
closure_expr_id: fn_node_id };
let upvar_capture = self.tables.upvar_capture(upvar_id);
let cmt_result = match upvar_capture {
ty::UpvarCapture::ByValue => {
@ -805,7 +808,7 @@ impl<'a, 'gcx, 'tcx> MemCategorizationContext<'a, 'gcx, 'tcx> {
// The environment of a closure is guaranteed to
// outlive any bindings introduced in the body of the
// closure itself.
scope: self.tcx.hir.local_def_id(upvar_id.closure_expr_id),
scope: DefId::local(upvar_id.closure_expr_id),
bound_region: ty::BrEnv
}));

9
src/librustc/ty/mod.rs
View File

@ -572,8 +572,8 @@ impl<T> Slice<T> {
/// by the upvar) and the id of the closure expression.
#[derive(Clone, Copy, PartialEq, Eq, Hash, RustcEncodable, RustcDecodable)]
pub struct UpvarId {
pub var_id: NodeId,
pub closure_expr_id: NodeId,
pub var_id: DefIndex,
pub closure_expr_id: DefIndex,
}
#[derive(Clone, PartialEq, Eq, Hash, Debug, RustcEncodable, RustcDecodable, Copy)]
@ -1983,6 +1983,11 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
}
}
pub fn local_var_name_str_def_index(self, def_index: DefIndex) -> InternedString {
let node_id = self.hir.as_local_node_id(DefId::local(def_index)).unwrap();
self.local_var_name_str(node_id)
}
pub fn expr_is_lval(self, expr: &hir::Expr) -> bool {
match expr.node {
hir::ExprPath(hir::QPath::Resolved(_, ref path)) => {

4
src/librustc/util/ppaux.rs
View File

@ -864,9 +864,9 @@ impl<'tcx> fmt::Display for ty::TyS<'tcx> {
impl fmt::Debug for ty::UpvarId {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "UpvarId({};`{}`;{})",
write!(f, "UpvarId({:?};`{}`;{:?})",
self.var_id,
ty::tls::with(|tcx| tcx.local_var_name_str(self.var_id)),
ty::tls::with(|tcx| tcx.local_var_name_str_def_index(self.var_id)),
self.closure_expr_id)
}
}

4
src/librustc_borrowck/borrowck/gather_loans/move_error.rs
View File

@ -93,11 +93,11 @@ fn report_move_errors<'a, 'tcx>(bccx: &BorrowckCtxt<'a, 'tcx>, errors: &Vec<Move
}
}
if let NoteClosureEnv(upvar_id) = error.move_from.note {
err.span_label(bccx.tcx.hir.span(upvar_id.var_id),
let var_node_id = bccx.tcx.hir.def_index_to_node_id(upvar_id.var_id);
err.span_label(bccx.tcx.hir.span(var_node_id),
"captured outer variable");
}
err.emit();
}
}

28
src/librustc_borrowck/borrowck/mod.rs
View File

@ -27,7 +27,7 @@ use rustc::middle::dataflow::DataFlowContext;
use rustc::middle::dataflow::BitwiseOperator;
use rustc::middle::dataflow::DataFlowOperator;
use rustc::middle::dataflow::KillFrom;
use rustc::hir::def_id::DefId;
use rustc::hir::def_id::{DefId, DefIndex};
use rustc::middle::expr_use_visitor as euv;
use rustc::middle::mem_categorization as mc;
use rustc::middle::mem_categorization::Categorization;
@ -323,8 +323,9 @@ pub enum LoanPathElem<'tcx> {
LpInterior(Option<DefId>, InteriorKind),
}
pub fn closure_to_block(closure_id: ast::NodeId,
fn closure_to_block(closure_id: DefIndex,
tcx: TyCtxt) -> ast::NodeId {
let closure_id = tcx.hir.def_index_to_node_id(closure_id);
match tcx.hir.get(closure_id) {
hir_map::NodeExpr(expr) => match expr.node {
hir::ExprClosure(.., body_id, _) => {
@ -845,7 +846,8 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
} else {
"consider changing this closure to take self by mutable reference"
};
err.span_help(self.tcx.hir.span(id), help);
let node_id = self.tcx.hir.def_index_to_node_id(id);
err.span_help(self.tcx.hir.span(node_id), help);
err
}
_ => {
@ -1181,7 +1183,9 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
_ => bug!()
};
if kind == ty::ClosureKind::Fn {
db.span_help(self.tcx.hir.span(upvar_id.closure_expr_id),
let closure_node_id =
self.tcx.hir.def_index_to_node_id(upvar_id.closure_expr_id);
db.span_help(self.tcx.hir.span(closure_node_id),
"consider changing this closure to take \
self by mutable reference");
}
@ -1214,7 +1218,9 @@ impl<'a, 'tcx> BorrowckCtxt<'a, 'tcx> {
loan_path: &LoanPath<'tcx>,
out: &mut String) {
match loan_path.kind {
LpUpvar(ty::UpvarId{ var_id: id, closure_expr_id: _ }) |
LpUpvar(ty::UpvarId { var_id: id, closure_expr_id: _ }) => {
out.push_str(&self.tcx.local_var_name_str_def_index(id));
}
LpVar(id) => {
out.push_str(&self.tcx.local_var_name_str(id));
}
@ -1352,8 +1358,11 @@ impl<'tcx> fmt::Debug for LoanPath<'tcx> {
}
LpUpvar(ty::UpvarId{ var_id, closure_expr_id }) => {
let s = ty::tls::with(|tcx| tcx.hir.node_to_string(var_id));
write!(f, "$({} captured by id={})", s, closure_expr_id)
let s = ty::tls::with(|tcx| {
let var_node_id = tcx.hir.def_index_to_node_id(var_id);
tcx.hir.node_to_string(var_node_id)
});
write!(f, "$({} captured by id={:?})", s, closure_expr_id)
}
LpDowncast(ref lp, variant_def_id) => {
@ -1384,7 +1393,10 @@ impl<'tcx> fmt::Display for LoanPath<'tcx> {
}
LpUpvar(ty::UpvarId{ var_id, closure_expr_id: _ }) => {
let s = ty::tls::with(|tcx| tcx.hir.node_to_user_string(var_id));
let s = ty::tls::with(|tcx| {
let var_node_id = tcx.hir.def_index_to_node_id(var_id);
tcx.hir.node_to_string(var_node_id)
});
write!(f, "$({} captured by closure)", s)
}

10
src/librustc_mir/build/mod.rs
View File

@ -368,10 +368,12 @@ fn construct_fn<'a, 'gcx, 'tcx, A>(hir: Cx<'a, 'gcx, 'tcx>,
// Gather the upvars of a closure, if any.
let upvar_decls: Vec<_> = tcx.with_freevars(fn_id, |freevars| {
freevars.iter().map(|fv| {
let var_id = tcx.hir.as_local_node_id(fv.def.def_id()).unwrap();
let var_def_id = fv.def.def_id();
let var_node_id = tcx.hir.as_local_node_id(var_def_id).unwrap();
let closure_expr_id = tcx.hir.local_def_id(fn_id).index;
let capture = hir.tables().upvar_capture(ty::UpvarId {
var_id: var_id,
closure_expr_id: fn_id
var_id: var_def_id.index,
closure_expr_id,
});
let by_ref = match capture {
ty::UpvarCapture::ByValue => false,
@ -381,7 +383,7 @@ fn construct_fn<'a, 'gcx, 'tcx, A>(hir: Cx<'a, 'gcx, 'tcx>,
debug_name: keywords::Invalid.name(),
by_ref: by_ref
};
if let Some(hir::map::NodeLocal(pat)) = tcx.hir.find(var_id) {
if let Some(hir::map::NodeLocal(pat)) = tcx.hir.find(var_node_id) {
if let hir::PatKind::Binding(_, _, ref ident, _) = pat.node {
decl.debug_name = ident.node;
}

17
src/librustc_mir/hair/cx/expr.rs
View File

@ -684,8 +684,8 @@ fn convert_var<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
ExprKind::VarRef { id: node_id }
}
Def::Upvar(def_id, index, closure_expr_id) => {
let id_var = cx.tcx.hir.as_local_node_id(def_id).unwrap();
Def::Upvar(var_def_id, index, closure_expr_id) => {
let id_var = cx.tcx.hir.as_local_node_id(var_def_id).unwrap();
debug!("convert_var(upvar({:?}, {:?}, {:?}))",
id_var,
index,
@ -768,8 +768,8 @@ fn convert_var<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
// ...but the upvar might be an `&T` or `&mut T` capture, at which
// point we need an implicit deref
let upvar_id = ty::UpvarId {
var_id: id_var,
closure_expr_id: closure_expr_id,
var_id: var_def_id.index,
closure_expr_id: closure_def_id.index,
};
match cx.tables().upvar_capture(upvar_id) {
ty::UpvarCapture::ByValue => field_kind,
@ -880,15 +880,16 @@ fn capture_freevar<'a, 'gcx, 'tcx>(cx: &mut Cx<'a, 'gcx, 'tcx>,
freevar: &hir::Freevar,
freevar_ty: Ty<'tcx>)
-> ExprRef<'tcx> {
let id_var = cx.tcx.hir.as_local_node_id(freevar.def.def_id()).unwrap();
let var_def_id = freevar.def.def_id();
let var_node_id = cx.tcx.hir.as_local_node_id(var_def_id).unwrap();
let upvar_id = ty::UpvarId {
var_id: id_var,
closure_expr_id: closure_expr.id,
var_id: var_def_id.index,
closure_expr_id: cx.tcx.hir.local_def_id(closure_expr.id).index,
};
let upvar_capture = cx.tables().upvar_capture(upvar_id);
let temp_lifetime = cx.region_maps.temporary_scope(closure_expr.id);
let var_ty = cx.tables()
.node_id_to_type(cx.tcx.hir.node_to_hir_id(id_var));
.node_id_to_type(cx.tcx.hir.node_to_hir_id(var_node_id));
let captured_var = Expr {
temp_lifetime: temp_lifetime,
ty: var_ty,

83
src/librustc_typeck/check/upvar.rs
View File

@ -50,8 +50,9 @@ use rustc::infer::UpvarRegion;
use syntax::ast;
use syntax_pos::Span;
use rustc::hir;
use rustc::hir::def_id::DefIndex;
use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
use rustc::util::nodemap::NodeMap;
use rustc::util::nodemap::FxHashMap;
use std::collections::hash_map::Entry;
@ -90,7 +91,7 @@ impl<'a, 'gcx, 'tcx> Visitor<'gcx> for InferBorrowKindVisitor<'a, 'gcx, 'tcx> {
impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
fn analyze_closure(&self,
(id, hir_id): (ast::NodeId, hir::HirId),
(closure_node_id, closure_hir_id): (ast::NodeId, hir::HirId),
span: Span,
body: &hir::Body,
capture_clause: hir::CaptureClause) {
@ -98,23 +99,29 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
* Analysis starting point.
*/
debug!("analyze_closure(id={:?}, body.id={:?})", id, body.id());
debug!("analyze_closure(id={:?}, body.id={:?})", closure_node_id, body.id());
let infer_kind = match self.tables.borrow_mut().closure_kinds.entry(hir_id.local_id) {
let infer_kind = match self.tables
.borrow_mut()
.closure_kinds
.entry(closure_hir_id.local_id) {
Entry::Occupied(_) => false,
Entry::Vacant(entry) => {
debug!("check_closure: adding closure {:?} as Fn", id);
debug!("check_closure: adding closure {:?} as Fn", closure_node_id);
entry.insert((ty::ClosureKind::Fn, None));
true
}
};
self.tcx.with_freevars(id, |freevars| {
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 def_id = freevar.def.def_id();
let var_node_id = self.tcx.hir.as_local_node_id(def_id).unwrap();
let upvar_id = ty::UpvarId { var_id: var_node_id,
closure_expr_id: id };
let var_def_id = freevar.def.def_id();
let upvar_id = ty::UpvarId {
var_id: var_def_id.index,
closure_expr_id: closure_def_id.index,
};
debug!("seed upvar_id {:?}", upvar_id);
let capture_kind = match capture_clause {
@ -139,7 +146,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
let region_maps = &self.tcx.region_maps(body_owner_def_id);
let mut delegate = InferBorrowKind {
fcx: self,
adjust_closure_kinds: NodeMap(),
adjust_closure_kinds: FxHashMap(),
adjust_upvar_captures: ty::UpvarCaptureMap::default(),
};
euv::ExprUseVisitor::with_infer(&mut delegate,
@ -151,8 +158,12 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
// Write the adjusted values back into the main tables.
if infer_kind {
if let Some(kind) = delegate.adjust_closure_kinds.remove(&id) {
self.tables.borrow_mut().closure_kinds.insert(hir_id.local_id, kind);
if let Some(kind) = delegate.adjust_closure_kinds
.remove(&closure_def_id.index) {
self.tables
.borrow_mut()
.closure_kinds
.insert(closure_hir_id.local_id, kind);
}
}
self.tables.borrow_mut().upvar_capture_map.extend(
@ -172,20 +183,20 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
// inference algorithm will reject it).
// Extract the type variables UV0...UVn.
let (def_id, closure_substs) = match self.node_ty(hir_id).sty {
let (def_id, closure_substs) = match self.node_ty(closure_hir_id).sty {
ty::TyClosure(def_id, substs) => (def_id, substs),
ref t => {
span_bug!(
span,
"type of closure expr {:?} is not a closure {:?}",
id, t);
closure_node_id, t);
}
};
// Equate the type variables with the actual types.
let final_upvar_tys = self.final_upvar_tys(id);
let final_upvar_tys = self.final_upvar_tys(closure_node_id);
debug!("analyze_closure: id={:?} closure_substs={:?} final_upvar_tys={:?}",
id, closure_substs, final_upvar_tys);
closure_node_id, closure_substs, final_upvar_tys);
for (upvar_ty, final_upvar_ty) in
closure_substs.upvar_tys(def_id, self.tcx).zip(final_upvar_tys)
{
@ -195,7 +206,6 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
// If we are also inferred the closure kind here,
// process any deferred resolutions.
if infer_kind {
let closure_def_id = self.tcx.hir.local_def_id(id);
let deferred_call_resolutions =
self.remove_deferred_call_resolutions(closure_def_id);
for deferred_call_resolution in deferred_call_resolutions {
@ -212,19 +222,21 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
// This may change if abstract return types of some sort are
// implemented.
let tcx = self.tcx;
let closure_def_index = tcx.hir.local_def_id(closure_id).index;
tcx.with_freevars(closure_id, |freevars| {
freevars.iter().map(|freevar| {
let def_id = freevar.def.def_id();
let var_id = tcx.hir.as_local_node_id(def_id).unwrap();
let freevar_ty = self.node_ty(tcx.hir.node_to_hir_id(var_id));
let var_def_id = freevar.def.def_id();
let var_node_id = tcx.hir.as_local_node_id(var_def_id).unwrap();
let freevar_ty = self.node_ty(tcx.hir.node_to_hir_id(var_node_id));
let upvar_id = ty::UpvarId {
var_id: var_id,
closure_expr_id: closure_id
var_id: var_def_id.index,
closure_expr_id: closure_def_index,
};
let capture = self.tables.borrow().upvar_capture(upvar_id);
debug!("var_id={:?} freevar_ty={:?} capture={:?}",
var_id, freevar_ty, capture);
var_node_id, freevar_ty, capture);
match capture {
ty::UpvarCapture::ByValue => freevar_ty,
@ -242,7 +254,7 @@ impl<'a, 'gcx, 'tcx> FnCtxt<'a, 'gcx, 'tcx> {
struct InferBorrowKind<'a, 'gcx: 'a+'tcx, 'tcx: 'a> {
fcx: &'a FnCtxt<'a, 'gcx, 'tcx>,
adjust_closure_kinds: NodeMap<(ty::ClosureKind, Option<(Span, ast::Name)>)>,
adjust_closure_kinds: FxHashMap<DefIndex, (ty::ClosureKind, Option<(Span, ast::Name)>)>,
adjust_upvar_captures: ty::UpvarCaptureMap<'tcx>,
}
@ -281,7 +293,7 @@ impl<'a, 'gcx, 'tcx> InferBorrowKind<'a, 'gcx, 'tcx> {
self.adjust_closure_kind(upvar_id.closure_expr_id,
ty::ClosureKind::FnOnce,
guarantor.span,
tcx.hir.name(upvar_id.var_id));
var_name(tcx, upvar_id.var_id));
self.adjust_upvar_captures.insert(upvar_id, ty::UpvarCapture::ByValue);
}
@ -295,7 +307,7 @@ impl<'a, 'gcx, 'tcx> InferBorrowKind<'a, 'gcx, 'tcx> {
self.adjust_closure_kind(upvar_id.closure_expr_id,
ty::ClosureKind::FnOnce,
guarantor.span,
tcx.hir.name(upvar_id.var_id));
var_name(tcx, upvar_id.var_id));
}
mc::NoteNone => {
}
@ -400,7 +412,7 @@ impl<'a, 'gcx, 'tcx> InferBorrowKind<'a, 'gcx, 'tcx> {
self.adjust_closure_kind(upvar_id.closure_expr_id,
ty::ClosureKind::FnMut,
cmt.span,
tcx.hir.name(upvar_id.var_id));
var_name(tcx, upvar_id.var_id));
true
}
@ -411,7 +423,7 @@ impl<'a, 'gcx, 'tcx> InferBorrowKind<'a, 'gcx, 'tcx> {
self.adjust_closure_kind(upvar_id.closure_expr_id,
ty::ClosureKind::FnMut,
cmt.span,
tcx.hir.name(upvar_id.var_id));
var_name(tcx, upvar_id.var_id));
true
}
@ -460,23 +472,23 @@ impl<'a, 'gcx, 'tcx> InferBorrowKind<'a, 'gcx, 'tcx> {
}
fn adjust_closure_kind(&mut self,
closure_id: ast::NodeId,
closure_id: DefIndex,
new_kind: ty::ClosureKind,
upvar_span: Span,
var_name: ast::Name) {
debug!("adjust_closure_kind(closure_id={}, new_kind={:?}, upvar_span={:?}, var_name={})",
debug!("adjust_closure_kind(closure_id={:?}, new_kind={:?}, upvar_span={:?}, var_name={})",
closure_id, new_kind, upvar_span, var_name);
let closure_kind = self.adjust_closure_kinds.get(&closure_id).cloned()
.or_else(|| {
let closure_id = self.fcx.tcx.hir.node_to_hir_id(closure_id);
let closure_id = self.fcx.tcx.hir.def_index_to_hir_id(closure_id);
let fcx_tables = self.fcx.tables.borrow();
fcx_tables.validate_hir_id(closure_id);
fcx_tables.closure_kinds.get(&closure_id.local_id).cloned()
});
if let Some((existing_kind, _)) = closure_kind {
debug!("adjust_closure_kind: closure_id={}, existing_kind={:?}, new_kind={:?}",
debug!("adjust_closure_kind: closure_id={:?}, existing_kind={:?}, new_kind={:?}",
closure_id, existing_kind, new_kind);
match (existing_kind, new_kind) {
@ -566,3 +578,8 @@ impl<'a, 'gcx, 'tcx> euv::Delegate<'tcx> for InferBorrowKind<'a, 'gcx, 'tcx> {
self.adjust_upvar_borrow_kind_for_mut(assignee_cmt);
}
}
fn var_name(tcx: ty::TyCtxt, var_def_index: DefIndex) -> ast::Name {
let var_node_id = tcx.hir.def_index_to_node_id(var_def_index);
tcx.hir.name(var_node_id)
}

9
src/librustc_typeck/check/writeback.rs
View File

@ -14,7 +14,7 @@
use check::FnCtxt;
use rustc::hir;
use rustc::hir::def_id::DefId;
use rustc::hir::def_id::{DefId, DefIndex};
use rustc::hir::intravisit::{self, Visitor, NestedVisitorMap};
use rustc::infer::{InferCtxt};
use rustc::ty::{self, Ty, TyCtxt};
@ -401,6 +401,13 @@ impl Locatable for ast::NodeId {
fn to_span(&self, tcx: &TyCtxt) -> Span { tcx.hir.span(*self) }
}
impl Locatable for DefIndex {
fn to_span(&self, tcx: &TyCtxt) -> Span {
let node_id = tcx.hir.def_index_to_node_id(*self);
tcx.hir.span(node_id)
}
}
impl Locatable for hir::HirId {
fn to_span(&self, tcx: &TyCtxt) -> Span {
let node_id = tcx.hir.definitions().find_node_for_hir_id(*self);