use compoundplace in debuginfo

Author: beepster4096

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

@@ -558,7 +558,12 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
         err: &mut Diag<'infcx>,
     ) {
         let var_info = self.body.var_debug_info.iter().find(|info| match info.value {
-            VarDebugInfoContents::Place(ref p) => p == place,
+            VarDebugInfoContents::Place(ref p) => p
+                .projection_chain
+                .iter()
+                .flatten()
+                .enumerate()
+                .all(|(i, elem)| place.projection.get(i) == Some(&elem)),
             _ => false,
         });
         let arg_name = if let Some(var_info) = var_info {

compiler/rustc_codegen_ssa/src/mir/debuginfo.rs

@@ -491,7 +491,9 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             } else {
                 match var.value {
                     mir::VarDebugInfoContents::Place(place) => {
-                        self.monomorphized_place_ty(place.as_ref())
+                        let tcx = bx.tcx();
+                        let place_ty = place.ty(self.mir, tcx);
+                        self.monomorphize(place_ty.ty)
                     }
                     mir::VarDebugInfoContents::Const(c) => self.monomorphize(c.ty()),
                 }
@@ -501,7 +503,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 let var_kind = if let Some(arg_index) = var.argument_index
                     && var.composite.is_none()
                     && let mir::VarDebugInfoContents::Place(place) = var.value
-                    && place.projection.is_empty()
+                    && place.as_local().is_some()
                 {
                     let arg_index = arg_index as usize;
                     if target_is_msvc {
@@ -566,7 +568,10 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                         source_info: var.source_info,
                         dbg_var,
                         fragment,
-                        projection: place.projection,
+                        // FIXME change field to be projection chain
+                        projection: bx
+                            .tcx()
+                            .mk_place_elems_from_iter(place.projection_chain.iter().flatten()),
                     });
                 }
                 mir::VarDebugInfoContents::Const(c) => {

compiler/rustc_middle/src/mir/mod.rs

@@ -1187,8 +1187,8 @@ impl<'tcx> LocalDecl<'tcx> {
 
 #[derive(Clone, TyEncodable, TyDecodable, HashStable, TypeFoldable, TypeVisitable)]
 pub enum VarDebugInfoContents<'tcx> {
-    /// This `Place` only contains projection which satisfy `can_use_in_debuginfo`.
-    Place(Place<'tcx>),
+    /// This `CompoundPlace` only contains projection which satisfy `can_use_in_debuginfo`.
+    Place(CompoundPlace<'tcx>),
     Const(ConstOperand<'tcx>),
 }
 

compiler/rustc_middle/src/mir/statement.rs

@@ -1,5 +1,6 @@
 //! Functionality for statements, operands, places, and things that appear in them.
 
+use smallvec::SmallVec;
 use tracing::{debug, instrument};
 
 use super::interpret::GlobalAlloc;
@@ -558,7 +559,7 @@ 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.
+/// kinds of places, requiring this struct to be used instead.
 #[derive(Copy, Clone, PartialEq, Eq, Hash, TyEncodable, HashStable, TypeFoldable, TypeVisitable)]
 pub struct CompoundPlace<'tcx> {
     pub local: Local,
@@ -579,6 +580,35 @@ pub struct CompoundPlaceRef<'tcx> {
 
 // these impls are bare-bones for now
 impl<'tcx> CompoundPlace<'tcx> {
+    pub fn from_place(place: Place<'tcx>, tcx: TyCtxt<'tcx>) -> CompoundPlace<'tcx> {
+        let mut segment_start = 0;
+        // size picked from sole user
+        let mut new_projection_chain = SmallVec::<[_; 2]>::new();
+
+        for (i, elem) in place.projection.iter().enumerate() {
+            if elem == PlaceElem::Deref && i > 0 {
+                new_projection_chain.push(tcx.mk_place_elems(&place.projection[segment_start..i]));
+                segment_start = i;
+            }
+        }
+
+        if segment_start == 0 {
+            new_projection_chain.push(place.projection);
+        } else {
+            new_projection_chain.push(tcx.mk_place_elems(&place.projection[segment_start..]));
+        }
+
+        if cfg!(debug_assertions) {
+            let new_projections: Vec<_> = new_projection_chain.iter().copied().flatten().collect();
+            assert_eq!(new_projections.as_slice(), place.projection.as_slice());
+        }
+
+        CompoundPlace {
+            local: place.local,
+            projection_chain: tcx.mk_place_elem_chain(&new_projection_chain),
+        }
+    }
+
     pub fn as_ref(&self) -> CompoundPlaceRef<'tcx> {
         let (last, base) = self
             .projection_chain
@@ -589,21 +619,75 @@ impl<'tcx> CompoundPlace<'tcx> {
         CompoundPlaceRef { local: self.local, projection_chain_base: base, last_projection: last }
     }
 
+    pub fn as_local(&self) -> Option<Local> {
+        if self.projection_chain.is_empty() { Some(self.local) } else { None }
+    }
+
+    pub fn local_or_deref_local(&self) -> Option<Local> {
+        self.as_ref().local_or_deref_local()
+    }
+
+    /// Returns a [`Place`] with only the first segment in the projection chain.
+    pub fn base_place(&self) -> Place<'tcx> {
+        Place {
+            local: self.local,
+            projection: self.projection_chain.first().copied().unwrap_or_default(),
+        }
+    }
+
+    /// Replaces the local and first segment of the projection with `new_base`.
+    pub fn replace_base_place(&mut self, new_base: Place<'tcx>, tcx: TyCtxt<'tcx>) {
+        self.local = new_base.local;
+        self.projection_chain =
+            match (new_base.projection.is_empty(), self.projection_chain.is_empty()) {
+                (false, false) => {
+                    let mut new_projection_chain = self.projection_chain.to_vec();
+                    new_projection_chain[0] = new_base.projection;
+                    tcx.mk_place_elem_chain(&new_projection_chain)
+                }
+                (false, true) => tcx.mk_place_elem_chain(&[new_base.projection]),
+
+                (true, false) => tcx.mk_place_elem_chain(&self.projection_chain[1..]),
+                (true, true) => List::empty(),
+            }
+        // FIXME: this logic is a mess
+        // maybe seperate out projection before first deref?
+    }
+
+    /// Replaces the local with `new_base`.
+    pub fn replace_local_with_place(&mut self, new_base: Place<'tcx>, tcx: TyCtxt<'tcx>) {
+        let base_place = self.base_place();
+
+        if new_base.projection.is_empty() {
+            self.local = new_base.local;
+        } else if base_place.is_indirect_first_projection() {
+            let mut new_projection_chain = Vec::with_capacity(self.projection_chain.len() + 1);
+            new_projection_chain.push(new_base.projection);
+            new_projection_chain.extend_from_slice(self.projection_chain);
+
+            self.local = new_base.local;
+            self.projection_chain = tcx.mk_place_elem_chain(&new_projection_chain);
+        } else {
+            self.replace_base_place(new_base.project_deeper(base_place.projection, tcx), tcx);
+        }
+    }
+
     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],
+                        last_projection: &self.projection_chain[i - 1],
                     }
+
+                    // FIXME: the fact that i messed up this logic the first time is good evidence that
+                    // the invariants are confusing and difficult to uphold
                 } else {
                     CompoundPlaceRef {
                         local: self.local,
@@ -612,6 +696,19 @@ impl<'tcx> CompoundPlace<'tcx> {
                     }
                 };
 
+                if cfg!(debug_assertions) {
+                    let self_projections: Vec<_> = self.projection_chain.iter().flatten().collect();
+                    let base_projections: Vec<_> = base
+                        .projection_chain_base
+                        .iter()
+                        .copied()
+                        .flatten()
+                        .chain(base.last_projection.iter().copied())
+                        .collect();
+
+                    assert_eq!(self_projections[..base_projections.len()], base_projections);
+                }
+
                 (base, elem)
             })
         })
@@ -626,6 +723,13 @@ impl<'tcx> CompoundPlace<'tcx> {
     }
 }
 
+impl From<Local> for CompoundPlace<'_> {
+    #[inline]
+    fn from(local: Local) -> Self {
+        CompoundPlace { local, projection_chain: List::empty() }
+    }
+}
+
 impl<'tcx> CompoundPlaceRef<'tcx> {
     pub fn ty<D: ?Sized>(&self, local_decls: &D, tcx: TyCtxt<'tcx>) -> PlaceTy<'tcx>
     where
@@ -635,6 +739,17 @@ impl<'tcx> CompoundPlaceRef<'tcx> {
             .projection_chain_ty(tcx, self.projection_chain_base)
             .multi_projection_ty(tcx, self.last_projection)
     }
+
+    pub fn local_or_deref_local(&self) -> Option<Local> {
+        match *self {
+            CompoundPlaceRef {
+                local,
+                projection_chain_base: [],
+                last_projection: [] | [ProjectionElem::Deref],
+            } => Some(local),
+            _ => None,
+        }
+    }
 }
 
 ///////////////////////////////////////////////////////////////////////////

compiler/rustc_middle/src/mir/visit.rs

@@ -923,7 +923,7 @@ macro_rules! make_mir_visitor {
                 match value {
                     VarDebugInfoContents::Const(c) => self.visit_const_operand(c, location),
                     VarDebugInfoContents::Place(place) =>
-                        self.visit_place(
+                        self.visit_compound_place(
                             place,
                             PlaceContext::NonUse(NonUseContext::VarDebugInfo),
                             location

compiler/rustc_middle/src/ty/codec.rs

@@ -298,6 +298,21 @@ impl<'tcx, D: TyDecoder<'tcx>> Decodable<D> for mir::Place<'tcx> {
     }
 }
 
+impl<'tcx, D: TyDecoder<'tcx>> Decodable<D> for mir::CompoundPlace<'tcx> {
+    fn decode(decoder: &mut D) -> Self {
+        let local: mir::Local = Decodable::decode(decoder);
+        let chain_len = decoder.read_usize();
+        let projection_chain =
+            decoder.interner().mk_place_elem_chain_from_iter((0..chain_len).map(|_| {
+                let projs_len = decoder.read_usize();
+                decoder.interner().mk_place_elems_from_iter(
+                    (0..projs_len).map::<mir::PlaceElem<'tcx>, _>(|_| Decodable::decode(decoder)),
+                )
+            }));
+        mir::CompoundPlace { local, projection_chain }
+    }
+}
+
 impl<'tcx, D: TyDecoder<'tcx>> Decodable<D> for ty::Region<'tcx> {
     fn decode(decoder: &mut D) -> Self {
         ty::Region::new_from_kind(decoder.interner(), Decodable::decode(decoder))

compiler/rustc_mir_build/src/builder/custom/parse.rs

@@ -260,7 +260,9 @@ impl<'a, 'tcx> ParseCtxt<'a, 'tcx> {
             let operand = self.parse_operand(operand)?;
             let value = match operand {
                 Operand::Constant(c) => VarDebugInfoContents::Const(*c),
-                Operand::Copy(p) | Operand::Move(p) => VarDebugInfoContents::Place(p),
+                Operand::Copy(p) | Operand::Move(p) => {
+                    VarDebugInfoContents::Place(CompoundPlace::from_place(p, self.tcx))
+                }
             };
             let dbginfo = VarDebugInfo {
                 name,

compiler/rustc_mir_build/src/builder/mod.rs

@@ -840,9 +840,9 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         let Some(closure_arg) = self.local_decls.get(ty::CAPTURE_STRUCT_LOCAL) else { return };
 
         let mut closure_ty = closure_arg.ty;
-        let mut closure_env_projs = vec![];
+        let mut closure_env_projs: &[_] = &[];
         if let ty::Ref(_, ty, _) = closure_ty.kind() {
-            closure_env_projs.push(ProjectionElem::Deref);
+            closure_env_projs = &[ProjectionElem::Deref];
             closure_ty = *ty;
         }
 
@@ -881,7 +881,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 
                 let mutability = captured_place.mutability;
 
-                let mut projs = closure_env_projs.clone();
+                let mut projs = closure_env_projs.to_vec();
                 projs.push(ProjectionElem::Field(FieldIdx::new(i), ty));
                 match capture {
                     ty::UpvarCapture::ByValue | ty::UpvarCapture::ByUse => {}
@@ -897,7 +897,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 self.var_debug_info.push(VarDebugInfo {
                     name,
                     source_info: SourceInfo::outermost(captured_place.var_ident.span),
-                    value: VarDebugInfoContents::Place(use_place),
+                    value: VarDebugInfoContents::Place(CompoundPlace::from_place(use_place, tcx)),
                     composite: None,
                     argument_index: None,
                 });

compiler/rustc_mir_transform/src/coroutine.rs

@@ -158,15 +158,29 @@ impl<'tcx> MutVisitor<'tcx> for SelfArgVisitor<'tcx> {
             }
         }
     }
-}
 
-fn replace_base<'tcx>(place: &mut Place<'tcx>, new_base: Place<'tcx>, tcx: TyCtxt<'tcx>) {
-    place.local = new_base.local;
+    fn visit_compound_place(
+        &mut self,
+        place: &mut CompoundPlace<'tcx>,
+        context: PlaceContext,
+        location: Location,
+    ) {
+        if place.local == SELF_ARG {
+            place.replace_local_with_place(self.new_base, self.tcx);
+        } else {
+            self.visit_local(&mut place.local, context, location);
 
-    let mut new_projection = new_base.projection.to_vec();
-    new_projection.append(&mut place.projection.to_vec());
+            for elem in place.projection_chain.iter().flatten() {
+                if let PlaceElem::Index(local) = elem {
+                    assert_ne!(local, SELF_ARG);
+                }
+            }
+        }
+    }
+}
 
-    place.projection = tcx.mk_place_elems(&new_projection);
+fn replace_base<'tcx>(place: &mut Place<'tcx>, new_base: Place<'tcx>, tcx: TyCtxt<'tcx>) {
+    *place = new_base.project_deeper(place.projection, tcx);
 }
 
 const SELF_ARG: Local = Local::from_u32(1);
@@ -406,6 +420,18 @@ impl<'tcx> MutVisitor<'tcx> for TransformVisitor<'tcx> {
         }
     }
 
+    fn visit_compound_place(
+        &mut self,
+        place: &mut CompoundPlace<'tcx>,
+        _context: PlaceContext,
+        _location: Location,
+    ) {
+        // Replace an Local in the remap with a coroutine struct access
+        if let Some(&Some((ty, variant_index, idx))) = self.remap.get(place.local) {
+            place.replace_local_with_place(self.make_field(variant_index, idx, ty), self.tcx);
+        }
+    }
+
     fn visit_basic_block_data(&mut self, block: BasicBlock, data: &mut BasicBlockData<'tcx>) {
         // Remove StorageLive and StorageDead statements for remapped locals
         for s in &mut data.statements {
@@ -1693,14 +1719,11 @@ impl EnsureCoroutineFieldAssignmentsNeverAlias<'_> {
 }
 
 impl<'tcx> Visitor<'tcx> for EnsureCoroutineFieldAssignmentsNeverAlias<'_> {
-    fn visit_place(&mut self, place: &Place<'tcx>, context: PlaceContext, location: Location) {
+    fn visit_place(&mut self, place: &Place<'tcx>, _context: PlaceContext, location: Location) {
         let Some(lhs) = self.assigned_local else {
             // This visitor only invokes `visit_place` for the right-hand side of an assignment
-            // and only after setting `self.assigned_local`. However, the default impl of
-            // `Visitor::super_body` may call `visit_place` with a `NonUseContext` for places
-            // with debuginfo. Ignore them here.
-            assert!(!context.is_use());
-            return;
+            // and only after setting `self.assigned_local`.
+            bug!()
         };
 
         let Some(rhs) = self.saved_local_for_direct_place(*place) else { return };