use rustc::ty::{self, TyCtxt};
use std::cmp::max;
-pub(super) fn places_conflict<'gcx, 'tcx>(
+pub(super) fn borrow_conflicts_with_place<'gcx, 'tcx>(
tcx: TyCtxt<'_, 'gcx, 'tcx>,
mir: &Mir<'tcx>,
borrow_place: &Place<'tcx>,
access: AccessDepth,
) -> bool {
debug!(
- "places_conflict({:?},{:?},{:?})",
+ "borrow_conflicts_with_place({:?},{:?},{:?})",
borrow_place, access_place, access
);
loop {
// loop invariant: borrow_c is always either equal to access_c or disjoint from it.
if let Some(borrow_c) = borrow_components.next() {
- debug!("places_conflict: borrow_c = {:?}", borrow_c);
+ debug!("borrow_conflicts_with_place: borrow_c = {:?}", borrow_c);
if let Some(access_c) = access_components.next() {
- debug!("places_conflict: access_c = {:?}", access_c);
+ debug!("borrow_conflicts_with_place: access_c = {:?}", access_c);
// Borrow and access path both have more components.
//
// idea, at least for now, so just give up and
// report a conflict. This is unsafe code anyway so
// the user could always use raw pointers.
- debug!("places_conflict: arbitrary -> conflict");
+ debug!("borrow_conflicts_with_place: arbitrary -> conflict");
return true;
}
Overlap::EqualOrDisjoint => {
Overlap::Disjoint => {
// We have proven the borrow disjoint - further
// projections will remain disjoint.
- debug!("places_conflict: disjoint");
+ debug!("borrow_conflicts_with_place: disjoint");
return false;
}
}
//
// e.g. a (mutable) borrow of `a[5]` while we read the
// array length of `a`.
- debug!("places_conflict: implicit field");
+ debug!("borrow_conflicts_with_place: implicit field");
return false;
}
// e.g. a borrow of `*x.y` while we shallowly access `x.y` or some
// prefix thereof - the shallow access can't touch anything behind
// the pointer.
- debug!("places_conflict: shallow access behind ptr");
+ debug!("borrow_conflicts_with_place: shallow access behind ptr");
return false;
}
(ProjectionElem::Deref, ty::Ref(_, _, hir::MutImmutable), _) => {
(ProjectionElem::Deref, ty::Ref(_, _, hir::MutMutable), AccessDepth::Drop) => {
// Values behind a mutatble reference are not access either by Dropping a
// value, or by StorageDead
- debug!("places_conflict: drop access behind ptr");
+ debug!("borrow_conflicts_with_place: drop access behind ptr");
return false;
}
// that the borrow can access a *part* of our place that
// our access cares about, so we still have a conflict.
if borrow_kind == BorrowKind::Shallow && access_components.next().is_some() {
- debug!("places_conflict: shallow borrow");
+ debug!("borrow_conflicts_with_place: shallow borrow");
return false;
} else {
- debug!("places_conflict: full borrow, CONFLICT");
+ debug!("borrow_conflicts_with_place: full borrow, CONFLICT");
return true;
}
}
///
/// NB: This particular impl strategy is not the most obvious. It was
/// chosen because it makes a measurable difference to NLL
-/// performance, as this code (`places_conflict`) is somewhat hot.
+/// performance, as this code (`borrow_conflicts_with_place`) is somewhat hot.
struct PlaceComponents<'p, 'tcx: 'p> {
component: &'p Place<'tcx>,
next: Option<&'p PlaceComponents<'p, 'tcx>>,