1 //! From the NLL RFC: "The deep [aka 'supporting'] prefixes for an
2 //! place are formed by stripping away fields and derefs, except that
3 //! we stop when we reach the deref of a shared reference. [...] "
5 //! "Shallow prefixes are found by stripping away fields, but stop at
6 //! any dereference. So: writing a path like `a` is illegal if `a.b`
7 //! is borrowed. But: writing `a` is legal if `*a` is borrowed,
8 //! whether or not `a` is a shared or mutable reference. [...] "
10 use super::MirBorrowckCtxt;
13 use rustc::mir::{Place, PlaceBase, PlaceRef, ProjectionElem, ReadOnlyBodyAndCache};
14 use rustc::ty::{self, TyCtxt};
16 pub trait IsPrefixOf<'cx, 'tcx> {
17 fn is_prefix_of(&self, other: PlaceRef<'cx, 'tcx>) -> bool;
20 impl<'cx, 'tcx> IsPrefixOf<'cx, 'tcx> for PlaceRef<'cx, 'tcx> {
21 fn is_prefix_of(&self, other: PlaceRef<'cx, 'tcx>) -> bool {
22 self.base == other.base
23 && self.projection.len() <= other.projection.len()
24 && self.projection == &other.projection[..self.projection.len()]
28 pub(super) struct Prefixes<'cx, 'tcx> {
29 body: ReadOnlyBodyAndCache<'cx, 'tcx>,
32 next: Option<PlaceRef<'cx, 'tcx>>,
35 #[derive(Copy, Clone, PartialEq, Eq, Debug)]
37 pub(super) enum PrefixSet {
38 /// Doesn't stop until it returns the base case (a Local or
41 /// Stops at any dereference.
43 /// Stops at the deref of a shared reference.
47 impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
48 /// Returns an iterator over the prefixes of `place`
49 /// (inclusive) from longest to smallest, potentially
50 /// terminating the iteration early based on `kind`.
51 pub(super) fn prefixes(
53 place_ref: PlaceRef<'cx, 'tcx>,
55 ) -> Prefixes<'cx, 'tcx> {
56 Prefixes { next: Some(place_ref), kind, body: self.body, tcx: self.infcx.tcx }
60 impl<'cx, 'tcx> Iterator for Prefixes<'cx, 'tcx> {
61 type Item = PlaceRef<'cx, 'tcx>;
62 fn next(&mut self) -> Option<Self::Item> {
63 let mut cursor = self.next?;
65 // Post-processing `place`: Enqueue any remaining
66 // work. Also, `place` may not be a prefix itself, but
67 // may hold one further down (e.g., we never return
68 // downcasts here, but may return a base of a downcast).
73 base: PlaceBase::Local(_),
76 | // search yielded this leaf
78 base: PlaceBase::Static(_),
86 projection: [proj_base @ .., elem],
89 ProjectionElem::Field(_ /*field*/, _ /*ty*/) => {
90 // FIXME: add union handling
91 self.next = Some(PlaceRef {
93 projection: proj_base,
97 ProjectionElem::Downcast(..) |
98 ProjectionElem::Subslice { .. } |
99 ProjectionElem::ConstantIndex { .. } |
100 ProjectionElem::Index(_) => {
103 projection: proj_base,
107 ProjectionElem::Deref => {
112 assert_eq!(*elem, ProjectionElem::Deref);
115 PrefixSet::Shallow => {
116 // Shallow prefixes are found by stripping away
117 // fields, but stop at *any* dereference.
118 // So we can just stop the traversal now.
123 // All prefixes: just blindly enqueue the base
124 // of the projection.
125 self.next = Some(PlaceRef {
127 projection: proj_base,
131 PrefixSet::Supporting => {
136 assert_eq!(self.kind, PrefixSet::Supporting);
137 // Supporting prefixes: strip away fields and
138 // derefs, except we stop at the deref of a shared
141 let ty = Place::ty_from(cursor.base, proj_base, *self.body, self.tcx).ty;
149 // don't continue traversing over derefs of raw pointers or shared
158 hir::Mutability::Mut,
160 self.next = Some(PlaceRef {
162 projection: proj_base,
167 ty::Adt(..) if ty.is_box() => {
168 self.next = Some(PlaceRef {
170 projection: proj_base,
175 _ => panic!("unknown type fed to Projection Deref."),