nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-11-23 23:34:48 +00:00
Code Issues Packages Projects Releases Wiki Activity

remove is_unique

Browse Source
This commit is contained in:
Ariel Ben-Yehuda 2017-12-07 21:11:10 +02:00
parent b64ddecae8
commit ed636c5c5a
1 changed files with 15 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

89
src/librustc_mir/borrow_check/mod.rs
View File

@ -1251,7 +1251,7 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
let mut error_reported = false;
match kind {
Write(WriteKind::MutableBorrow(BorrowKind::Unique)) => {
if let Err(_place_err) = self.is_unique(place) {
if let Err(_place_err) = self.is_mutable(place, LocalMutationIsAllowed::Yes) {
span_bug!(span, "&unique borrow for {:?} should not fail", place);
}
}
@ -1358,25 +1358,24 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
// Mutably borrowed data is mutable, but only if we have a
// unique path to the `&mut`
hir::MutMutable => {
match self.is_upvar_field_projection(&proj.base) {
let mode = match self.is_upvar_field_projection(&proj.base) {
Some(field) if {
self.mir.upvar_decls[field.index()].by_ref
} => {
self.is_mutable(&proj.base,
is_local_mutation_allowed)
}
_ => self.is_unique(&proj.base)
}
} => is_local_mutation_allowed,
_ => LocalMutationIsAllowed::Yes
};
self.is_mutable(&proj.base, mode)
}
}
}
ty::TyRawPtr(tnm) => {
match tnm.mutbl {
// `*const` raw pointers are not mutable
hir::MutImmutable => Err(place),
hir::MutImmutable => return Err(place),
// `*mut` raw pointers are always mutable, regardless of context
// The users have to check by themselve.
hir::MutMutable => Ok(()),
hir::MutMutable => return Ok(()),
}
}
// `Box<T>` owns its content, so mutable if its location is mutable
@ -1394,80 +1393,22 @@ impl<'cx, 'gcx, 'tcx> MirBorrowckCtxt<'cx, 'gcx, 'tcx> {
ProjectionElem::ConstantIndex { .. } |
ProjectionElem::Subslice { .. } |
ProjectionElem::Downcast(..) => {
let field_projection = self.is_upvar_field_projection(place);
if let Some(field) = field_projection {
if let Some(field) = self.is_upvar_field_projection(place) {
let decl = &self.mir.upvar_decls[field.index()];
debug!("decl.mutability={:?} local_mutation_is_allowed={:?} place={:?}",
decl, is_local_mutation_allowed, place);
return match (decl.mutability, is_local_mutation_allowed) {
match (decl.mutability, is_local_mutation_allowed) {
(Mutability::Not, LocalMutationIsAllowed::No) |
(Mutability::Not, LocalMutationIsAllowed::ExceptUpvars)
=> Err(place),
(Mutability::Not, LocalMutationIsAllowed::Yes) |
(Mutability::Mut, _) => self.is_unique(&proj.base),
};
}
self.is_mutable(&proj.base, is_local_mutation_allowed)
}
}
}
}
}
/// Does this place have a unique path
fn is_unique<'d>(&self, place: &'d Place<'tcx>) -> Result<(), &'d Place<'tcx>> {
match *place {
Place::Local(..) => {
// Local variables are unique
Ok(())
}
Place::Static(ref static_) => {
if !self.tcx.is_static_mut(static_.def_id) {
Err(place)
} else {
Ok(())
}
}
Place::Projection(ref proj) => {
match proj.elem {
ProjectionElem::Deref => {
let base_ty = proj.base.ty(self.mir, self.tcx).to_ty(self.tcx);
// `Box<T>` referent is unique if box is a unique spot
if base_ty.is_box() {
return self.is_unique(&proj.base);
}
// Otherwise we check the kind of deref to decide
match base_ty.sty {
ty::TyRef(_, tnm) => {
match tnm.mutbl {
// place represent an aliased location
hir::MutImmutable => Err(place),
// `&mut T` is as unique as the context in which it is found
hir::MutMutable => self.is_unique(&proj.base),
}
(Mutability::Mut, _) =>
self.is_mutable(&proj.base, is_local_mutation_allowed)
}
ty::TyRawPtr(tnm) => {
match tnm.mutbl {
// `*mut` can be aliased, but we leave it to user
hir::MutMutable => Ok(()),
// `*const` is treated the same as `*mut`
hir::MutImmutable => Ok(()),
}
}
// Deref should only be for reference, pointers or boxes
_ => bug!("Deref of unexpected type: {:?}", base_ty),
} else {
self.is_mutable(&proj.base, is_local_mutation_allowed)
}
}
// Other projections are unique if the base is unique
ProjectionElem::Field(..) |
ProjectionElem::Index(..) |
ProjectionElem::ConstantIndex { .. } |
ProjectionElem::Subslice { .. } |
ProjectionElem::Downcast(..) => self.is_unique(&proj.base),
}
}
}