Thread target type through, make CoerceChange type change happen in some visitors

aapoalas · aapoalas · commit 2b5cd0fd18ab · 2026-03-12T19:44:50.000+02:00
diff --git a/compiler/rustc_borrowck/src/borrow_set.rs b/compiler/rustc_borrowck/src/borrow_set.rs
@@ -302,7 +302,7 @@ impl<'a, 'tcx> Visitor<'tcx> for GatherBorrows<'a, 'tcx> {
             };
 
             self.local_map.entry(borrowed_place.local).or_default().insert(idx);
-        } else if let &mir::Rvalue::Reborrow(mutability, borrowed_place) = rvalue {
+        } else if let &mir::Rvalue::Reborrow(mutability, borrowed_place, _target) = rvalue {
             let borrowed_place_ty = borrowed_place.ty(self.body, self.tcx).ty;
             let &ty::Adt(reborrowed_adt, _reborrowed_args) = borrowed_place_ty.kind() else {
                 unreachable!()
diff --git a/compiler/rustc_borrowck/src/dataflow.rs b/compiler/rustc_borrowck/src/dataflow.rs
@@ -549,7 +549,7 @@ impl<'tcx> rustc_mir_dataflow::Analysis<'tcx> for Borrows<'_, 'tcx> {
     ) {
         match &stmt.kind {
             mir::StatementKind::Assign(box (lhs, rhs)) => {
-                if let mir::Rvalue::Ref(_, _, place) | mir::Rvalue::Reborrow(_, place) = rhs {
+                if let mir::Rvalue::Ref(_, _, place) | mir::Rvalue::Reborrow(_, place, _) = rhs {
                     if place.ignore_borrow(
                         self.tcx,
                         self.body,
diff --git a/compiler/rustc_borrowck/src/lib.rs b/compiler/rustc_borrowck/src/lib.rs
@@ -1509,7 +1509,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
                 );
             }
 
-            &Rvalue::Reborrow(mutability, place) => {
+            &Rvalue::Reborrow(mutability, place, _target) => {
                 let access_kind = (
                     Deep,
                     if mutability == Mutability::Mut {
diff --git a/compiler/rustc_borrowck/src/polonius/legacy/loan_invalidations.rs b/compiler/rustc_borrowck/src/polonius/legacy/loan_invalidations.rs
@@ -275,7 +275,7 @@ impl<'a, 'tcx> LoanInvalidationsGenerator<'a, 'tcx> {
                 self.access_place(location, place, access_kind, LocalMutationIsAllowed::No);
             }
 
-            &Rvalue::Reborrow(mutability, place) => {
+            &Rvalue::Reborrow(mutability, place, _target) => {
                 let access_kind = (
                     Deep,
                     if mutability == Mutability::Mut {
diff --git a/compiler/rustc_borrowck/src/type_check/mod.rs b/compiler/rustc_borrowck/src/type_check/mod.rs
@@ -551,8 +551,8 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
 
 impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
     fn visit_assign(&mut self, place: &Place<'tcx>, rvalue: &Rvalue<'tcx>, location: Location) {
-        // check rvalue is Reborrow
-        if let Rvalue::Reborrow(mutability, rvalue) = rvalue {
+        if let Rvalue::Reborrow(mutability, rvalue, _) = rvalue {
+            // check rvalue is Reborrow
             self.add_generic_reborrow_constraint(*mutability, location, place, rvalue);
         } else {
             // rest of the cases
@@ -637,11 +637,11 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                 debug!(?rv_ty);
                 let rv_ty = self.normalize(rv_ty, location);
                 debug!("normalized rv_ty: {:?}", rv_ty);
-                // Note: we've checked Reborrow/CoerceShared type matches
-                // separately in fn visit_assign.
-                if !matches!(rv, Rvalue::Reborrow(_, _))
-                    && let Err(terr) =
-                        self.sub_types(rv_ty, place_ty, location.to_locations(), category)
+                if let Rvalue::Reborrow(mutability, rvalue, _) = rv {
+                    // check rvalue is Reborrow
+                    self.add_generic_reborrow_constraint(*mutability, location, place, rvalue);
+                } else if let Err(terr) =
+                    self.sub_types(rv_ty, place_ty, location.to_locations(), category)
                 {
                     span_mirbug!(
                         self,
diff --git a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
@@ -514,7 +514,9 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             // Generic shared reborrowing is not (necessarily) a simple memcpy, but currently the
             // coherence check places such restrictions on the CoerceShared trait as to guarantee
             // that it is.
-            mir::Rvalue::Reborrow(_, place) => self.codegen_operand(bx, &mir::Operand::Copy(place)),
+            mir::Rvalue::Reborrow(_, place, _) => {
+                self.codegen_operand(bx, &mir::Operand::Copy(place))
+            }
 
             mir::Rvalue::RawPtr(kind, place) => {
                 let mk_ptr = move |tcx: TyCtxt<'tcx>, ty: Ty<'tcx>| {
diff --git a/compiler/rustc_const_eval/src/check_consts/qualifs.rs b/compiler/rustc_const_eval/src/check_consts/qualifs.rs
@@ -255,7 +255,7 @@ where
             in_place::<Q, _>(cx, in_local, place.as_ref())
         }
 
-        Rvalue::Reborrow(_, place) => in_place::<Q, _>(cx, in_local, place.as_ref()),
+        Rvalue::Reborrow(_, place, _) => in_place::<Q, _>(cx, in_local, place.as_ref()),
 
         Rvalue::WrapUnsafeBinder(op, _) => in_operand::<Q, _>(cx, in_local, op),
 
diff --git a/compiler/rustc_const_eval/src/check_consts/resolver.rs b/compiler/rustc_const_eval/src/check_consts/resolver.rs
@@ -191,7 +191,7 @@ where
                 }
             }
 
-            mir::Rvalue::Reborrow(mutability, borrowed_place) => {
+            mir::Rvalue::Reborrow(mutability, borrowed_place, _target) => {
                 if !borrowed_place.is_indirect() && mutability.is_mut() {
                     let place_ty = borrowed_place.ty(self.ccx.body, self.ccx.tcx).ty;
                     if Q::in_any_value_of_ty(self.ccx, place_ty) {
diff --git a/compiler/rustc_const_eval/src/interpret/step.rs b/compiler/rustc_const_eval/src/interpret/step.rs
@@ -270,7 +270,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 self.copy_op_allow_transmute(&op, &dest)?;
             }
 
-            Reborrow(_, place) => {
+            Reborrow(_, place, _) => {
                 let op = self.eval_place_to_op(place, Some(dest.layout))?;
                 self.copy_op(&op, &dest)?;
             }
diff --git a/compiler/rustc_middle/src/mir/pretty.rs b/compiler/rustc_middle/src/mir/pretty.rs
@@ -1251,7 +1251,7 @@ impl<'tcx> Debug for Rvalue<'tcx> {
                 with_no_trimmed_paths!(write!(fmt, "wrap_binder!({op:?}; {ty})"))
             }
 
-            Reborrow(mutability, ref place) => {
+            Reborrow(mutability, ref place, _) => {
                 if mutability.is_mut() {
                     write!(fmt, "reborrow {place:?}")
                 } else {
diff --git a/compiler/rustc_middle/src/mir/statement.rs b/compiler/rustc_middle/src/mir/statement.rs
@@ -761,7 +761,7 @@ impl<'tcx> Rvalue<'tcx> {
             | Rvalue::CopyForDeref(_)
             | Rvalue::Repeat(_, _)
             | Rvalue::Ref(_, _, _)
-            | Rvalue::Reborrow(_, _)
+            | Rvalue::Reborrow(_, _, _)
             | Rvalue::ThreadLocalRef(_)
             | Rvalue::RawPtr(_, _)
             | Rvalue::Cast(
@@ -806,10 +806,7 @@ impl<'tcx> Rvalue<'tcx> {
                 let place_ty = place.ty(local_decls, tcx).ty;
                 Ty::new_ref(tcx, reg, place_ty, bk.to_mutbl_lossy())
             }
-            Rvalue::Reborrow(_mutability, ref place) => {
-                // FIXME(@aapoalas): when mutability is Not, type changes.
-                place.ty(local_decls, tcx).ty
-            }
+            Rvalue::Reborrow(_, _, target) => target,
             Rvalue::RawPtr(kind, ref place) => {
                 let place_ty = place.ty(local_decls, tcx).ty;
                 Ty::new_ptr(tcx, place_ty, kind.to_mutbl_lossy())
diff --git a/compiler/rustc_middle/src/mir/syntax.rs b/compiler/rustc_middle/src/mir/syntax.rs
@@ -1489,7 +1489,7 @@ pub enum Rvalue<'tcx> {
     /// This is produced by the [`ExprKind::Reborrow`].
     ///
     /// [`ExprKind::Reborrow`]: crate::thir::ExprKind::Reborrow
-    Reborrow(Mutability, Place<'tcx>),
+    Reborrow(Mutability, Place<'tcx>, Ty<'tcx>),
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, TyEncodable, TyDecodable, Hash, HashStable)]
diff --git a/compiler/rustc_middle/src/mir/visit.rs b/compiler/rustc_middle/src/mir/visit.rs
@@ -730,7 +730,7 @@ macro_rules! make_mir_visitor {
                         self.visit_place(path, ctx, location);
                     }
 
-                    Rvalue::Reborrow(mutability, place) => {
+                    Rvalue::Reborrow(mutability, place, _) => {
                         self.visit_place(
                             place,
                             match mutability {
diff --git a/compiler/rustc_middle/src/thir.rs b/compiler/rustc_middle/src/thir.rs
@@ -556,6 +556,7 @@ pub enum ExprKind<'tcx> {
     Reborrow {
         source: ExprId,
         mutability: Mutability,
+        target: Ty<'tcx>,
     },
 }
 
diff --git a/compiler/rustc_middle/src/thir/visit.rs b/compiler/rustc_middle/src/thir/visit.rs
@@ -187,7 +187,7 @@ pub fn walk_expr<'thir, 'tcx: 'thir, V: Visitor<'thir, 'tcx>>(
         }
         ThreadLocalRef(_) => {}
         Yield { value } => visitor.visit_expr(&visitor.thir()[value]),
-        Reborrow { source: _, mutability: _ } => {}
+        Reborrow { .. } => {}
     }
 }
 
diff --git a/compiler/rustc_mir_build/src/builder/expr/as_place.rs b/compiler/rustc_mir_build/src/builder/expr/as_place.rs
@@ -590,7 +590,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 let temp = unpack!(block = this.as_temp(block, temp_lifetime, expr_id, mutability));
                 block.and(PlaceBuilder::from(temp))
             }
-            ExprKind::Reborrow { source: _, mutability: _ } => {
+            ExprKind::Reborrow { .. } => {
                 todo!();
             }
         }
diff --git a/compiler/rustc_mir_build/src/builder/expr/as_rvalue.rs b/compiler/rustc_mir_build/src/builder/expr/as_rvalue.rs
@@ -431,9 +431,9 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 );
                 block.and(Rvalue::Use(operand))
             }
-            ExprKind::Reborrow { source, mutability } => {
+            ExprKind::Reborrow { source, mutability, target } => {
                 let temp = unpack!(block = this.as_temp(block, scope, source, mutability));
-                block.and(Rvalue::Reborrow(mutability, temp.into()))
+                block.and(Rvalue::Reborrow(mutability, temp.into(), target))
             }
         }
     }
diff --git a/compiler/rustc_mir_build/src/builder/expr/into.rs b/compiler/rustc_mir_build/src/builder/expr/into.rs
@@ -882,13 +882,13 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 this.cfg.push_assign(block, source_info, destination, rvalue);
                 block.unit()
             }
-            ExprKind::Reborrow { source, mutability } => {
+            ExprKind::Reborrow { source, mutability, target } => {
                 let place = unpack!(block = this.as_place(block, source));
                 this.cfg.push_assign(
                     block,
                     source_info,
                     destination,
-                    Rvalue::Reborrow(mutability, place.into()),
+                    Rvalue::Reborrow(mutability, place.into(), target),
                 );
                 block.unit()
             }
diff --git a/compiler/rustc_mir_build/src/thir/cx/expr.rs b/compiler/rustc_mir_build/src/thir/cx/expr.rs
@@ -285,7 +285,8 @@ impl<'tcx> ThirBuildCx<'tcx> {
             }
             Adjust::GenericReborrow(mutability) => {
                 let expr = self.thir.exprs.push(expr);
-                let kind = ExprKind::Reborrow { source: expr, mutability };
+                let kind =
+                    ExprKind::Reborrow { source: expr, mutability, target: adjustment.target };
 
                 kind
             }
diff --git a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
@@ -365,7 +365,7 @@ impl<'p, 'tcx> MatchVisitor<'p, 'tcx> {
             | VarRef { .. }
             | ZstLiteral { .. }
             | Yield { .. } => true,
-            ExprKind::Reborrow { source: _, mutability: _ } => {
+            ExprKind::Reborrow { .. } => {
                 todo!();
             }
         }
diff --git a/compiler/rustc_mir_build/src/thir/print.rs b/compiler/rustc_mir_build/src/thir/print.rs
@@ -600,7 +600,7 @@ impl<'a, 'tcx> ThirPrinter<'a, 'tcx> {
                 self.print_expr(*value, depth_lvl + 2);
                 print_indented!(self, "}", depth_lvl);
             }
-            ExprKind::Reborrow { source: _, mutability: _ } => {
+            ExprKind::Reborrow { source: _, mutability: _, target: _ } => {
                 print_indented!(self, "Reborrow {", depth_lvl);
                 print_indented!(self, "source:", depth_lvl + 1);
                 print_indented!(self, "mutability:", depth_lvl + 1);
diff --git a/compiler/rustc_mir_dataflow/src/impls/borrowed_locals.rs b/compiler/rustc_mir_dataflow/src/impls/borrowed_locals.rs
@@ -79,7 +79,7 @@ where
             // the layout of generators.
             Rvalue::RawPtr(_, borrowed_place)
             | Rvalue::Ref(_, BorrowKind::Mut { .. } | BorrowKind::Shared, borrowed_place)
-            | Rvalue::Reborrow(_, borrowed_place) => {
+            | Rvalue::Reborrow(_, borrowed_place, _) => {
                 if !borrowed_place.is_indirect() {
                     self.trans.gen_(borrowed_place.local);
                 }
diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs
@@ -1040,7 +1040,7 @@ impl<'body, 'a, 'tcx> VnState<'body, 'a, 'tcx> {
                 self.simplify_place_projection(place, location);
                 return self.new_pointer(*place, AddressKind::Ref(borrow_kind));
             }
-            Rvalue::Reborrow(_mutability, place) => {
+            Rvalue::Reborrow(_mutability, place, _target) => {
                 // FIXME(@aapoalas): when mutability is Not, the type should change.
                 let mut operand = Operand::Copy(place);
                 let val = self.simplify_operand(&mut operand, location);
diff --git a/compiler/rustc_mir_transform/src/known_panics_lint.rs b/compiler/rustc_mir_transform/src/known_panics_lint.rs
@@ -418,7 +418,7 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
             }
 
             // Do not try creating references (#67862)
-            Rvalue::RawPtr(_, place) | Rvalue::Ref(_, _, place) | Rvalue::Reborrow(_, place) => {
+            Rvalue::RawPtr(_, place) | Rvalue::Ref(_, _, place) | Rvalue::Reborrow(_, place, _) => {
                 trace!("skipping RawPtr | Ref | Reborrow for {:?}", place);
 
                 // This may be creating mutable references or immutable references to cells.
@@ -550,7 +550,7 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
                 self.eval_operand(operand)?.into()
             }
 
-            CopyForDeref(place) | Reborrow(_, place) => self.eval_place(place)?.into(),
+            CopyForDeref(place) | Reborrow(_, place, _) => self.eval_place(place)?.into(),
 
             BinaryOp(bin_op, box (ref left, ref right)) => {
                 let left = self.eval_operand(left)?;
diff --git a/compiler/rustc_mir_transform/src/promote_consts.rs b/compiler/rustc_mir_transform/src/promote_consts.rs
@@ -575,7 +575,7 @@ impl<'tcx> Validator<'_, 'tcx> {
                 self.validate_ref(*kind, place)?;
             }
 
-            Rvalue::Reborrow(_, place) => {
+            Rvalue::Reborrow(_, place, _) => {
                 // FIXME(@aapoalas): should probably have a place_simplified like above.
                 let op = &Operand::Copy(*place);
                 self.validate_operand(op)?
diff --git a/compiler/rustc_public/src/mir/body.rs b/compiler/rustc_public/src/mir/body.rs
@@ -595,7 +595,7 @@ pub enum Rvalue {
     /// CoerceShared trait. See [`Rvalue::Reborrow`] for a more detailed explanation.
     ///
     /// [`Rvalue::Reborrow`]: rustc_middle::mir::Rvalue::Reborrow
-    Reborrow(Mutability, Place),
+    Reborrow(Mutability, Place, Ty),
 }
 
 impl Rvalue {
@@ -610,10 +610,7 @@ impl Rvalue {
                 let place_ty = place.ty(locals)?;
                 Ok(Ty::new_ref(reg.clone(), place_ty, bk.to_mutable_lossy()))
             }
-            Rvalue::Reborrow(_mutability, place) => {
-                // FIXME(@aapoalas): when mutability is Not, the type should change.
-                place.ty(locals)
-            }
+            Rvalue::Reborrow(_, _, target) => Ok(*target),
             Rvalue::AddressOf(mutability, place) => {
                 let place_ty = place.ty(locals)?;
                 Ok(Ty::new_ptr(place_ty, mutability.to_mutable_lossy()))
diff --git a/compiler/rustc_public/src/mir/pretty.rs b/compiler/rustc_public/src/mir/pretty.rs
@@ -380,12 +380,12 @@ fn pretty_rvalue<W: Write>(writer: &mut W, rval: &Rvalue) -> io::Result<()> {
             };
             write!(writer, "{kind}{place:?}")
         }
-        Rvalue::Reborrow(mutability, place) => {
+        Rvalue::Reborrow(mutability, place, target) => {
             let kind = match mutability {
                 Mutability::Not => "Reborrow",
                 Mutability::Mut => "CoerceShared",
             };
-            write!(writer, "${kind}({place:?})")
+            write!(writer, "${kind}({place:?}) as {target}")
         }
         Rvalue::Repeat(op, cnst) => {
             write!(writer, "[{}; {}]", pretty_operand(op), pretty_ty_const(cnst))
diff --git a/compiler/rustc_public/src/mir/visit.rs b/compiler/rustc_public/src/mir/visit.rs
@@ -273,7 +273,7 @@ macro_rules! make_mir_visitor {
                         let pcx = PlaceContext { is_mut: matches!(kind, BorrowKind::Mut { .. }) };
                         self.visit_place(place, pcx, location);
                     }
-                    Rvalue::Reborrow(mutability, place) => {
+                    Rvalue::Reborrow(mutability, place, _) => {
                         let pcx = PlaceContext { is_mut: matches!(mutability, Mutability::Mut) };
                         self.visit_place(place, pcx, location);
                     }
diff --git a/compiler/rustc_public/src/unstable/convert/stable/mir.rs b/compiler/rustc_public/src/unstable/convert/stable/mir.rs
@@ -205,9 +205,11 @@ impl<'tcx> Stable<'tcx> for mir::Rvalue<'tcx> {
                 kind.stable(tables, cx),
                 place.stable(tables, cx),
             ),
-            Reborrow(kind, place) => {
-                crate::mir::Rvalue::Reborrow(kind.stable(tables, cx), place.stable(tables, cx))
-            }
+            Reborrow(kind, place, target) => crate::mir::Rvalue::Reborrow(
+                kind.stable(tables, cx),
+                place.stable(tables, cx),
+                target.stable(tables, cx),
+            ),
             ThreadLocalRef(def_id) => {
                 crate::mir::Rvalue::ThreadLocalRef(tables.crate_item(*def_id))
             }
diff --git a/compiler/rustc_ty_utils/src/consts.rs b/compiler/rustc_ty_utils/src/consts.rs
@@ -207,7 +207,7 @@ fn recurse_build<'tcx>(
         | ExprKind::ThreadLocalRef(_) => {
             error(GenericConstantTooComplexSub::OperationNotSupported(node.span))?
         }
-        ExprKind::Reborrow { source: _, mutability: _ } => {
+        ExprKind::Reborrow { .. } => {
             todo!();
         }
     })
@@ -307,7 +307,7 @@ impl<'a, 'tcx> IsThirPolymorphic<'a, 'tcx> {
             | thir::ExprKind::InlineAsm(_)
             | thir::ExprKind::ThreadLocalRef(_)
             | thir::ExprKind::Yield { .. } => false,
-            thir::ExprKind::Reborrow { source: _, mutability: _ } => {
+            thir::ExprKind::Reborrow { .. } => {
                 todo!();
             }
         }

Original file line number	Diff line number	Diff line change
`@@ -1509,7 +1509,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {`
`1509`	`1509`	`);`
`1510`	`1510`	`}`
`1511`	`1511`
`1512`		`- &Rvalue::Reborrow(mutability, place) => {`
	`1512`	`+ &Rvalue::Reborrow(mutability, place, _target) => {`
`1513`	`1513`	`let access_kind = (`
`1514`	`1514`	`Deep,`
`1515`	`1515`	`if mutability == Mutability::Mut {`
Original file line number	Diff line number	Diff line change
`@@ -275,7 +275,7 @@ impl<'a, 'tcx> LoanInvalidationsGenerator<'a, 'tcx> {`
`275`	`275`	`self.access_place(location, place, access_kind, LocalMutationIsAllowed::No);`
`276`	`276`	`}`
`277`	`277`
`278`		`- &Rvalue::Reborrow(mutability, place) => {`
	`278`	`+ &Rvalue::Reborrow(mutability, place, _target) => {`
`279`	`279`	`let access_kind = (`
`280`	`280`	`Deep,`
`281`	`281`	`if mutability == Mutability::Mut {`
Original file line number	Diff line number	Diff line change
`@@ -255,7 +255,7 @@ where`
`255`	`255`	`in_place::<Q, _>(cx, in_local, place.as_ref())`
`256`	`256`	`}`
`257`	`257`
`258`		`- Rvalue::Reborrow(_, place) => in_place::<Q, _>(cx, in_local, place.as_ref()),`
	`258`	`+ Rvalue::Reborrow(_, place, _) => in_place::<Q, _>(cx, in_local, place.as_ref()),`
`259`	`259`
`260`	`260`	`Rvalue::WrapUnsafeBinder(op, _) => in_operand::<Q, _>(cx, in_local, op),`
`261`	`261`
Original file line number	Diff line number	Diff line change
`@@ -191,7 +191,7 @@ where`
`191`	`191`	`}`
`192`	`192`	`}`
`193`	`193`
`194`		`- mir::Rvalue::Reborrow(mutability, borrowed_place) => {`
	`194`	`+ mir::Rvalue::Reborrow(mutability, borrowed_place, _target) => {`
`195`	`195`	`if !borrowed_place.is_indirect() && mutability.is_mut() {`
`196`	`196`	`let place_ty = borrowed_place.ty(self.ccx.body, self.ccx.tcx).ty;`
`197`	`197`	`if Q::in_any_value_of_ty(self.ccx, place_ty) {`
Original file line number	Diff line number	Diff line change
`@@ -270,7 +270,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {`
`270`	`270`	`self.copy_op_allow_transmute(&op, &dest)?;`
`271`	`271`	`}`
`272`	`272`
`273`		`- Reborrow(_, place) => {`
	`273`	`+ Reborrow(_, place, _) => {`
`274`	`274`	`let op = self.eval_place_to_op(place, Some(dest.layout))?;`
`275`	`275`	`self.copy_op(&op, &dest)?;`
`276`	`276`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1251,7 +1251,7 @@ impl<'tcx> Debug for Rvalue<'tcx> {`
`1251`	`1251`	`with_no_trimmed_paths!(write!(fmt, "wrap_binder!({op:?}; {ty})"))`
`1252`	`1252`	`}`
`1253`	`1253`
`1254`		`- Reborrow(mutability, ref place) => {`
	`1254`	`+ Reborrow(mutability, ref place, _) => {`
`1255`	`1255`	`if mutability.is_mut() {`
`1256`	`1256`	`write!(fmt, "reborrow {place:?}")`
`1257`	`1257`	`} else {`