visit_compound_place

beepster4096 · beepster4096 · commit 76b6446e17f6 · 2025-09-18T02:07:22.000-07:00
diff --git a/compiler/rustc_borrowck/src/type_check/mod.rs b/compiler/rustc_borrowck/src/type_check/mod.rs
@@ -19,7 +19,7 @@ use rustc_infer::infer::{
     BoundRegionConversionTime, InferCtxt, NllRegionVariableOrigin, RegionVariableOrigin,
 };
 use rustc_infer::traits::PredicateObligations;
-use rustc_middle::mir::visit::{NonMutatingUseContext, PlaceContext, Visitor};
+use rustc_middle::mir::visit::{NonMutatingUseContext, PlaceContext, ProjectionBase, Visitor};
 use rustc_middle::mir::*;
 use rustc_middle::traits::query::NoSolution;
 use rustc_middle::ty::adjustment::PointerCoercion;
@@ -1807,13 +1807,15 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
         }
     }
 
-    fn visit_projection_elem(
+    fn visit_projection_elem<P>(
         &mut self,
-        place: PlaceRef<'tcx>,
+        place: P,
         elem: PlaceElem<'tcx>,
         context: PlaceContext,
         location: Location,
-    ) {
+    ) where
+        P: ProjectionBase<'tcx>,
+    {
         let tcx = self.tcx();
         let base_ty = place.ty(self.body(), tcx);
         match elem {
diff --git a/compiler/rustc_middle/src/mir/statement.rs b/compiler/rustc_middle/src/mir/statement.rs
@@ -589,14 +589,6 @@ impl<'tcx> CompoundPlace<'tcx> {
         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 {
@@ -624,6 +616,14 @@ impl<'tcx> CompoundPlace<'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)
+    }
 }
 
 impl<'tcx> CompoundPlaceRef<'tcx> {
diff --git a/compiler/rustc_middle/src/mir/visit.rs b/compiler/rustc_middle/src/mir/visit.rs
@@ -180,6 +180,15 @@ macro_rules! make_mir_visitor {
                 self.super_place(place, context, location);
             }
 
+            fn visit_compound_place(
+                &mut self,
+                place: & $($mutability)? CompoundPlace<'tcx>,
+                context: PlaceContext,
+                location: Location,
+            ) {
+                self.super_compound_place(place, context, location);
+            }
+
             visit_place_fns!($($mutability)?);
 
             /// This is called for every constant in the MIR body and every `required_consts`
@@ -1182,6 +1191,45 @@ macro_rules! visit_place_fns {
                 | PlaceElem::Downcast(..) => None,
             }
         }
+
+        fn super_compound_place(
+            &mut self,
+            place: &mut CompoundPlace<'tcx>,
+            context: PlaceContext,
+            location: Location,
+        ) {
+            self.visit_local(&mut place.local, context, location);
+
+            if let Some(new_projection_chain) =
+                self.process_projection_chain(&place.projection_chain, location)
+            {
+                place.projection_chain = self.tcx().mk_place_elem_chain(&new_projection_chain);
+            }
+        }
+
+        fn process_projection_chain<'a>(
+            &mut self,
+            projection_chain: &'a [&'tcx List<PlaceElem<'tcx>>],
+            location: Location,
+        ) -> Option<Vec<&'tcx List<PlaceElem<'tcx>>>> {
+            let mut projection_chain = Cow::Borrowed(projection_chain);
+
+            for i in 0..projection_chain.len() {
+                if let Some(segment) = projection_chain.get(i) {
+                    if let Some(segment) = self.process_projection(segment, location) {
+                        // This converts the borrowed projection chain into `Cow::Owned(_)` and returns a
+                        // clone of the projection chain so we can mutate and reintern later.
+                        let vec = projection_chain.to_mut();
+                        vec[i] = self.tcx().mk_place_elems(&segment);
+                    }
+                }
+            }
+
+            match projection_chain {
+                Cow::Borrowed(_) => None,
+                Cow::Owned(vec) => Some(vec),
+            }
+        }
     };
 
     () => {
@@ -1194,13 +1242,15 @@ macro_rules! visit_place_fns {
             self.super_projection(place_ref, context, location);
         }
 
-        fn visit_projection_elem(
+        fn visit_projection_elem<P>(
             &mut self,
-            place_ref: PlaceRef<'tcx>,
+            place_ref: P,
             elem: PlaceElem<'tcx>,
             context: PlaceContext,
             location: Location,
-        ) {
+        ) where
+            P: ProjectionBase<'tcx>,
+        {
             self.super_projection_elem(place_ref, elem, context, location);
         }
 
@@ -1235,13 +1285,15 @@ macro_rules! visit_place_fns {
             }
         }
 
-        fn super_projection_elem(
+        fn super_projection_elem<P>(
             &mut self,
-            _place_ref: PlaceRef<'tcx>,
+            _place_ref: P,
             elem: PlaceElem<'tcx>,
             context: PlaceContext,
             location: Location,
-        ) {
+        ) where
+            P: ProjectionBase<'tcx>,
+        {
             match elem {
                 ProjectionElem::OpaqueCast(ty)
                 | ProjectionElem::Subtype(ty)
@@ -1267,6 +1319,28 @@ macro_rules! visit_place_fns {
                 | ProjectionElem::Downcast(_, _) => {}
             }
         }
+
+        fn super_compound_place(
+            &mut self,
+            place: &CompoundPlace<'tcx>,
+            mut context: PlaceContext,
+            location: Location,
+        ) {
+            if !place.projection_chain.is_empty() && context.is_use() {
+                // ^ Only change the context if it is a real use, not a "use" in debuginfo.
+                context = if context.is_mutating_use() {
+                    PlaceContext::MutatingUse(MutatingUseContext::Projection)
+                } else {
+                    PlaceContext::NonMutatingUse(NonMutatingUseContext::Projection)
+                };
+            }
+
+            self.visit_local(place.local, context, location);
+
+            for (base, elem) in place.iter_projections().rev() {
+                self.visit_projection_elem(base, elem, context, location);
+            }
+        }
     };
 }
 
@@ -1492,3 +1566,28 @@ where
         self.visit_projection(place.as_ref(), ctxt, location);
     }
 }
+
+/// Base of a projection in [`Visitor::visit_projection_elem`].
+pub trait ProjectionBase<'tcx>: Debug + Copy {
+    fn ty<D: ?Sized>(&self, local_decls: &D, tcx: TyCtxt<'tcx>) -> PlaceTy<'tcx>
+    where
+        D: HasLocalDecls<'tcx>;
+}
+
+impl<'tcx> ProjectionBase<'tcx> for PlaceRef<'tcx> {
+    fn ty<D: ?Sized>(&self, local_decls: &D, tcx: TyCtxt<'tcx>) -> PlaceTy<'tcx>
+    where
+        D: HasLocalDecls<'tcx>,
+    {
+        self.ty(local_decls, tcx)
+    }
+}
+
+impl<'tcx> ProjectionBase<'tcx> for CompoundPlaceRef<'tcx> {
+    fn ty<D: ?Sized>(&self, local_decls: &D, tcx: TyCtxt<'tcx>) -> PlaceTy<'tcx>
+    where
+        D: HasLocalDecls<'tcx>,
+    {
+        self.ty(local_decls, tcx)
+    }
+}
diff --git a/compiler/rustc_mir_transform/src/dataflow_const_prop.rs b/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
@@ -14,7 +14,7 @@ use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::def::DefKind;
 use rustc_middle::bug;
 use rustc_middle::mir::interpret::{InterpResult, Scalar};
-use rustc_middle::mir::visit::{MutVisitor, PlaceContext, Visitor};
+use rustc_middle::mir::visit::{MutVisitor, PlaceContext, ProjectionBase, Visitor};
 use rustc_middle::mir::*;
 use rustc_middle::ty::{self, Ty, TyCtxt};
 use rustc_mir_dataflow::fmt::DebugWithContext;
@@ -1069,13 +1069,15 @@ struct OperandCollector<'a, 'b, 'tcx> {
 }
 
 impl<'tcx> Visitor<'tcx> for OperandCollector<'_, '_, 'tcx> {
-    fn visit_projection_elem(
+    fn visit_projection_elem<P>(
         &mut self,
-        _: PlaceRef<'tcx>,
+        _: P,
         elem: PlaceElem<'tcx>,
         _: PlaceContext,
         location: Location,
-    ) {
+    ) where
+        P: ProjectionBase<'tcx>,
+    {
         if let PlaceElem::Index(local) = elem
             && let Some(value) =
                 self.visitor.try_make_constant(self.ecx, local.into(), self.state, self.map)
diff --git a/compiler/rustc_mir_transform/src/validate.rs b/compiler/rustc_mir_transform/src/validate.rs
@@ -9,7 +9,7 @@ use rustc_index::bit_set::DenseBitSet;
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_infer::traits::{Obligation, ObligationCause};
 use rustc_middle::mir::coverage::CoverageKind;
-use rustc_middle::mir::visit::{NonUseContext, PlaceContext, Visitor};
+use rustc_middle::mir::visit::{NonUseContext, PlaceContext, ProjectionBase, Visitor};
 use rustc_middle::mir::*;
 use rustc_middle::ty::adjustment::PointerCoercion;
 use rustc_middle::ty::print::with_no_trimmed_paths;
@@ -646,13 +646,15 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
         self.super_operand(operand, location);
     }
 
-    fn visit_projection_elem(
+    fn visit_projection_elem<P>(
         &mut self,
-        place_ref: PlaceRef<'tcx>,
+        place_ref: P,
         elem: PlaceElem<'tcx>,
         context: PlaceContext,
         location: Location,
-    ) {
+    ) where
+        P: ProjectionBase<'tcx>,
+    {
         match elem {
             ProjectionElem::OpaqueCast(ty)
                 if self.body.phase >= MirPhase::Runtime(RuntimePhase::Initial) =>
@@ -925,6 +927,40 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
         self.super_place(place, cntxt, location);
     }
 
+    fn visit_compound_place(
+        &mut self,
+        place: &CompoundPlace<'tcx>,
+        cntxt: PlaceContext,
+        location: Location,
+    ) {
+        // Set off any `bug!`s in the type computation code
+        let _ = place.ty(&self.body.local_decls, self.tcx);
+
+        for (i, projection) in place.projection_chain.iter().enumerate() {
+            if projection.is_empty() {
+                self.fail(location, format!("compound place {place:?} has empty segment {i}"));
+            }
+
+            if i > 0 && projection.first() != Some(&ProjectionElem::Deref) {
+                self.fail(
+                    location,
+                    format!(
+                        "compound place {place:?} has later segment without deref (segment {i})"
+                    ),
+                );
+            }
+
+            if projection[1..].contains(&ProjectionElem::Deref) {
+                self.fail(
+                location,
+                format!("compound place {place:?} has deref as a later projection in segment {i} (it is only permitted as the first projection)"),
+            );
+            }
+        }
+
+        self.super_compound_place(place, cntxt, location);
+    }
+
     fn visit_rvalue(&mut self, rvalue: &Rvalue<'tcx>, location: Location) {
         macro_rules! check_kinds {
             ($t:expr, $text:literal, $typat:pat) => {
