use rustc::mir::repr::{StatementKind, Terminator};
use rustc::util::nodemap::FnvHashMap;
-use std::cell::{Cell, RefCell};
+use std::cell::{Cell};
use std::collections::hash_map::Entry;
use std::fmt;
use std::iter;
struct MovePathDataBuilder<'a, 'tcx: 'a> {
mir: &'a Mir<'tcx>,
- pre_move_paths: RefCell<Vec<PreMovePath<'tcx>>>,
- rev_lookup: RefCell<MovePathLookup<'tcx>>,
+ pre_move_paths: Vec<PreMovePath<'tcx>>,
+ rev_lookup: MovePathLookup<'tcx>,
}
/// Tables mapping from an l-value to its MovePathIndex.
impl<'a, 'tcx> MovePathDataBuilder<'a, 'tcx> {
fn lookup(&mut self, lval: &Lvalue<'tcx>) -> Lookup<MovePathIndex> {
- let proj = {
- let mut rev_lookup = self.rev_lookup.borrow_mut();
- match *lval {
- Lvalue::Var(var_idx) =>
- return rev_lookup.lookup_var(var_idx),
- Lvalue::Temp(temp_idx) =>
- return rev_lookup.lookup_temp(temp_idx),
- Lvalue::Arg(arg_idx) =>
- return rev_lookup.lookup_arg(arg_idx),
- Lvalue::Static(_def_id) =>
- return rev_lookup.lookup_static(),
- Lvalue::ReturnPointer =>
- return rev_lookup.lookup_return_pointer(),
- Lvalue::Projection(ref proj) => {
- proj
- }
+ let proj = match *lval {
+ Lvalue::Var(var_idx) =>
+ return self.rev_lookup.lookup_var(var_idx),
+ Lvalue::Temp(temp_idx) =>
+ return self.rev_lookup.lookup_temp(temp_idx),
+ Lvalue::Arg(arg_idx) =>
+ return self.rev_lookup.lookup_arg(arg_idx),
+ Lvalue::Static(_def_id) =>
+ return self.rev_lookup.lookup_static(),
+ Lvalue::ReturnPointer =>
+ return self.rev_lookup.lookup_return_pointer(),
+ Lvalue::Projection(ref proj) => {
+ proj
}
- // drop the rev_lookup here ...
};
let base_index = self.move_path_for(&proj.base);
-
- // ... restablish exclusive access to rev_lookup here.
- let mut rev_lookup = self.rev_lookup.borrow_mut();
- rev_lookup.lookup_proj(proj, base_index)
+ self.rev_lookup.lookup_proj(proj, base_index)
}
- // Caller must ensure self's RefCells (i.e. `self.pre_move_paths`
- // and `self.rev_lookup`) are not mutably borrowed.
fn move_path_for(&mut self, lval: &Lvalue<'tcx>) -> MovePathIndex {
let lookup: Lookup<MovePathIndex> = self.lookup(lval);
// `lookup` is either the previously assigned index or a
// newly-allocated one.
- debug_assert!(lookup.idx() <= self.pre_move_paths.borrow().len());
+ debug_assert!(lookup.idx() <= self.pre_move_paths.len());
if let Lookup(LookupKind::Generate, mpi) = lookup {
let parent;
let idx = self.move_path_for(&proj.base);
parent = Some(idx);
- let mut pre_move_paths = self.pre_move_paths.borrow_mut();
- let parent_move_path = &mut pre_move_paths[idx.idx()];
+ let parent_move_path = &mut self.pre_move_paths[idx.idx()];
// At last: Swap in the new first_child.
sibling = parent_move_path.first_child.get();
first_child: Cell::new(None),
};
- let mut pre_move_paths = self.pre_move_paths.borrow_mut();
- pre_move_paths.push(move_path);
+ self.pre_move_paths.push(move_path);
}
return lookup.1;
// straight-forward than mutable borrows in this instance.)
let mut builder = MovePathDataBuilder {
mir: mir,
- pre_move_paths: RefCell::new(Vec::new()),
- rev_lookup: RefCell::new(MovePathLookup::new()),
+ pre_move_paths: Vec::new(),
+ rev_lookup: MovePathLookup::new(),
};
for bb in bbs {
// All such paths were not referenced ...
//
// well you know, lets actually try just asserting that the path map *is* complete.
- assert_eq!(path_map.len(), builder.pre_move_paths.borrow().len());
- path_map.fill_to(builder.pre_move_paths.borrow().len() - 1);
+ assert_eq!(path_map.len(), builder.pre_move_paths.len());
+ path_map.fill_to(builder.pre_move_paths.len() - 1);
- let pre_move_paths = builder.pre_move_paths.into_inner();
+ let pre_move_paths = builder.pre_move_paths;
let move_paths: Vec<_> = pre_move_paths.into_iter()
.map(|p| p.into_move_path())
.collect();
moves: moves,
loc_map: LocMap { map: loc_map },
path_map: PathMap { map: path_map },
- rev_lookup: builder.rev_lookup.into_inner(),
+ rev_lookup: builder.rev_lookup,
}
}