-use rustc::ty::{self, TyCtxt};
+use rustc::ty::{Ty, TyCtxt};
use rustc::mir::*;
use rustc::util::nodemap::FxHashMap;
use rustc_data_structures::indexed_vec::{Idx, IndexVec};
}
impl<T> LocationMap<T> where T: Default + Clone {
- fn new(mir: &Mir<'_>) -> Self {
+ fn new(mir: &Body<'_>) -> Self {
LocationMap {
map: mir.basic_blocks().iter().map(|block| {
vec![T::default(); block.statements.len()+1]
}
impl Init {
- crate fn span<'gcx>(&self, mir: &Mir<'gcx>) -> Span {
+ crate fn span<'gcx>(&self, mir: &Body<'gcx>) -> Span {
match self.location {
InitLocation::Argument(local) => mir.local_decls[local].source_info.span,
InitLocation::Statement(location) => mir.source_info(location).span,
// unknown place, but will rather return the nearest available
// parent.
pub fn find(&self, place: &Place<'tcx>) -> LookupResult {
- match *place {
- Place::Base(PlaceBase::Local(local)) => LookupResult::Exact(self.locals[local]),
- Place::Base(PlaceBase::Static(..)) => LookupResult::Parent(None),
- Place::Projection(ref proj) => {
- match self.find(&proj.base) {
- LookupResult::Exact(base_path) => {
- match self.projections.get(&(base_path, proj.elem.lift())) {
- Some(&subpath) => LookupResult::Exact(subpath),
- None => LookupResult::Parent(Some(base_path))
- }
- }
- inexact => inexact
+ place.iterate(|place_base, place_projection| {
+ let mut result = match place_base {
+ PlaceBase::Local(local) => self.locals[*local],
+ PlaceBase::Static(..) => return LookupResult::Parent(None),
+ };
+
+ for proj in place_projection {
+ if let Some(&subpath) = self.projections.get(&(result, proj.elem.lift())) {
+ result = subpath;
+ } else {
+ return LookupResult::Parent(Some(result));
}
}
- }
+
+ LookupResult::Exact(result)
+ })
}
pub fn find_local(&self, local: Local) -> MovePathIndex {
/// implements `Drop`. Rust maintains invariant that all `Drop`
/// ADT's remain fully-initialized so that user-defined destructor
/// can safely read from all of the ADT's fields.
- InteriorOfTypeWithDestructor { container_ty: ty::Ty<'tcx> },
+ InteriorOfTypeWithDestructor { container_ty: Ty<'tcx> },
/// Illegal move due to attempt to move out of a slice or array.
- InteriorOfSliceOrArray { ty: ty::Ty<'tcx>, is_index: bool, },
+ InteriorOfSliceOrArray { ty: Ty<'tcx>, is_index: bool, },
}
#[derive(Debug)]
}
impl<'a, 'gcx, 'tcx> MoveData<'tcx> {
- pub fn gather_moves(mir: &Mir<'tcx>, tcx: TyCtxt<'a, 'gcx, 'tcx>)
+ pub fn gather_moves(mir: &Body<'tcx>, tcx: TyCtxt<'a, 'gcx, 'tcx>)
-> Result<Self, (Self, Vec<(Place<'tcx>, MoveError<'tcx>)>)> {
builder::gather_moves(mir, tcx)
}