add CompoundPlace and CompoundPlaceRef

Author: beepster4096

compiler/rustc_middle/src/mir/pretty.rs

@@ -1270,6 +1270,30 @@ impl Debug for PlaceRef<'_> {
     }
 }
 
+impl Debug for CompoundPlace<'_> {
+    fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
+        self.as_ref().fmt(fmt)
+    }
+}
+
+impl Debug for CompoundPlaceRef<'_> {
+    fn fmt(&self, fmt: &mut Formatter<'_>) -> fmt::Result {
+        pre_fmt_projection(self.last_projection, fmt)?;
+        for projection in self.projection_chain_base.iter().rev() {
+            pre_fmt_projection(projection, fmt)?;
+        }
+
+        write!(fmt, "{:?}", self.local)?;
+
+        for projection in self.projection_chain_base {
+            post_fmt_projection(projection, fmt)?;
+        }
+        post_fmt_projection(self.last_projection, fmt)?;
+
+        Ok(())
+    }
+}
+
 fn pre_fmt_projection(projection: &[PlaceElem<'_>], fmt: &mut Formatter<'_>) -> fmt::Result {
     for &elem in projection.iter().rev() {
         match elem {

compiler/rustc_middle/src/mir/statement.rs

@@ -157,6 +157,17 @@ impl<'tcx> PlaceTy<'tcx> {
         elems.iter().fold(self, |place_ty, &elem| place_ty.projection_ty(tcx, elem))
     }
 
+    pub fn projection_chain_ty(
+        self,
+        tcx: TyCtxt<'tcx>,
+        chain: &[&List<PlaceElem<'tcx>>],
+    ) -> PlaceTy<'tcx> {
+        chain
+            .iter()
+            .flat_map(|&elems| elems)
+            .fold(self, |place_ty, elem| place_ty.projection_ty(tcx, elem))
+    }
+
     /// Convenience wrapper around `projection_ty_core` for `PlaceElem`,
     /// where we can just use the `Ty` that is already stored inline on
     /// field projection elems.
@@ -544,6 +555,88 @@ impl From<Local> for PlaceRef<'_> {
     }
 }
 
+/// A place possibly containing derefs in the middle of its projection by chaining projection lists.
+///
+/// In `AnalysisPhase::PostCleanup` and later, [`Place`] and [`PlaceRef`] cannot represent these
+/// kinds of places.
+#[derive(Copy, Clone, PartialEq, Eq, Hash, TyEncodable, HashStable, TypeFoldable, TypeVisitable)]
+pub struct CompoundPlace<'tcx> {
+    pub local: Local,
+    /// Invariants:
+    /// - All segments in the chain other than the first must start with a deref.
+    /// - Derefs may only appear at the start of a segment.
+    /// - No segment may be empty.
+    pub projection_chain: &'tcx List<&'tcx List<PlaceElem<'tcx>>>,
+}
+
+/// Borrowed form of [`CompoundPlace`].
+#[derive(Clone, Copy, PartialEq, Eq, Hash)]
+pub struct CompoundPlaceRef<'tcx> {
+    pub local: Local,
+    pub projection_chain_base: &'tcx [&'tcx List<PlaceElem<'tcx>>],
+    pub last_projection: &'tcx [PlaceElem<'tcx>],
+}
+
+// these impls are bare-bones for now
+impl<'tcx> CompoundPlace<'tcx> {
+    pub fn as_ref(&self) -> CompoundPlaceRef<'tcx> {
+        let (last, base) = self
+            .projection_chain
+            .split_last()
+            .map(|(&last, base)| (last, base))
+            .unwrap_or_default();
+
+        CompoundPlaceRef { local: self.local, projection_chain_base: base, last_projection: last }
+    }
+
+    pub fn ty<D: ?Sized>(&self, local_decls: &D, tcx: TyCtxt<'tcx>) -> PlaceTy<'tcx>
+    where
+        D: HasLocalDecls<'tcx>,
+    {
+        PlaceTy::from_ty(local_decls.local_decls()[self.local].ty)
+            .projection_chain_ty(tcx, self.projection_chain)
+    }
+
+    pub fn iter_projections(
+        self,
+    ) -> impl Iterator<Item = (CompoundPlaceRef<'tcx>, PlaceElem<'tcx>)> + DoubleEndedIterator {
+        self.projection_chain.iter().enumerate().flat_map(move |(i, projs)| {
+            projs.iter().enumerate().map(move |(j, elem)| {
+                let base = if j == 0 && i > 0 {
+                    // last_projection should only be empty if projection_chain_base is too
+                    // otherwise it has to have a deref at least
+
+                    debug_assert_eq!(elem, PlaceElem::Deref);
+                    CompoundPlaceRef {
+                        local: self.local,
+                        projection_chain_base: &self.projection_chain[..i - 1],
+                        last_projection: &projs[..=j],
+                    }
+                } else {
+                    CompoundPlaceRef {
+                        local: self.local,
+                        projection_chain_base: &self.projection_chain[..i],
+                        last_projection: &projs[..j],
+                    }
+                };
+
+                (base, elem)
+            })
+        })
+    }
+}
+
+impl<'tcx> CompoundPlaceRef<'tcx> {
+    pub fn ty<D: ?Sized>(&self, local_decls: &D, tcx: TyCtxt<'tcx>) -> PlaceTy<'tcx>
+    where
+        D: HasLocalDecls<'tcx>,
+    {
+        PlaceTy::from_ty(local_decls.local_decls()[self.local].ty)
+            .projection_chain_ty(tcx, self.projection_chain_base)
+            .multi_projection_ty(tcx, self.last_projection)
+    }
+}
+
 ///////////////////////////////////////////////////////////////////////////
 // Operands
 

compiler/rustc_middle/src/ty/context.rs

@@ -934,6 +934,7 @@ pub struct CtxtInterners<'tcx> {
     clauses: InternedSet<'tcx, ListWithCachedTypeInfo<Clause<'tcx>>>,
     projs: InternedSet<'tcx, List<ProjectionKind>>,
     place_elems: InternedSet<'tcx, List<PlaceElem<'tcx>>>,
+    place_elem_chains: InternedSet<'tcx, List<&'tcx List<PlaceElem<'tcx>>>>,
     const_: InternedSet<'tcx, WithCachedTypeInfo<ty::ConstKind<'tcx>>>,
     pat: InternedSet<'tcx, PatternKind<'tcx>>,
     const_allocation: InternedSet<'tcx, Allocation>,
@@ -972,6 +973,7 @@ impl<'tcx> CtxtInterners<'tcx> {
             clauses: InternedSet::with_capacity(N),
             projs: InternedSet::with_capacity(N * 4),
             place_elems: InternedSet::with_capacity(N * 2),
+            place_elem_chains: InternedSet::with_capacity(N * 2), // FIXME non-empirical factor - just copying place_elems
             const_: InternedSet::with_capacity(N * 2),
             pat: InternedSet::with_capacity(N),
             const_allocation: InternedSet::with_capacity(N),
@@ -2779,6 +2781,7 @@ slice_interners!(
     poly_existential_predicates: intern_poly_existential_predicates(PolyExistentialPredicate<'tcx>),
     projs: pub mk_projs(ProjectionKind),
     place_elems: pub mk_place_elems(PlaceElem<'tcx>),
+    place_elem_chains: pub mk_place_elem_chain(&'tcx List<PlaceElem<'tcx>>),
     bound_variable_kinds: pub mk_bound_variable_kinds(ty::BoundVariableKind),
     fields: pub mk_fields(FieldIdx),
     local_def_ids: intern_local_def_ids(LocalDefId),
@@ -3169,6 +3172,14 @@ impl<'tcx> TyCtxt<'tcx> {
         T::collect_and_apply(iter, |xs| self.mk_place_elems(xs))
     }
 
+    pub fn mk_place_elem_chain_from_iter<I, T>(self, iter: I) -> T::Output
+    where
+        I: Iterator<Item = T>,
+        T: CollectAndApply<&'tcx List<PlaceElem<'tcx>>, &'tcx List<&'tcx List<PlaceElem<'tcx>>>>,
+    {
+        T::collect_and_apply(iter, |xs| self.mk_place_elem_chain(xs))
+    }
+
     pub fn mk_fields_from_iter<I, T>(self, iter: I) -> T::Output
     where
         I: Iterator<Item = T>,

compiler/rustc_middle/src/ty/structural_impls.rs

@@ -797,6 +797,7 @@ macro_rules! list_fold {
 list_fold! {
     &'tcx ty::List<ty::PolyExistentialPredicate<'tcx>> : mk_poly_existential_predicates,
     &'tcx ty::List<PlaceElem<'tcx>> : mk_place_elems,
+    &'tcx ty::List<&'tcx ty::List<PlaceElem<'tcx>>> : mk_place_elem_chain,
     &'tcx ty::List<ty::Pattern<'tcx>> : mk_patterns,
     &'tcx ty::List<ty::ArgOutlivesPredicate<'tcx>> : mk_outlives,
 }