Fix const-eval CoerceShared reborrow leaf

Author: P8L1

compiler/rustc_const_eval/src/interpret/step.rs

@@ -7,6 +7,7 @@ use std::iter;
 use either::Either;
 use rustc_abi::{FIRST_VARIANT, FieldIdx};
 use rustc_data_structures::fx::FxHashSet;
+use rustc_hir::Mutability;
 use rustc_index::IndexSlice;
 use rustc_middle::ty::reborrow::{self, CoerceSharedFieldPairError};
 use rustc_middle::ty::{self, Instance, Ty};
@@ -207,28 +208,12 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             }
 
             Ref(_, borrow_kind, place) => {
-                let src = self.eval_place(place)?;
-                let place = self.force_allocation(&src)?;
-                let mut val = ImmTy::from_immediate(place.to_ref(self), dest.layout);
-                // A fresh reference was created, make sure it gets retagged with the right mode.
                 let mode = if borrow_kind.is_two_phase_borrow() {
                     RetagMode::TwoPhase
                 } else {
                     RetagMode::Default
                 };
-                M::with_retag_mode(self, mode, |ecx| {
-                    // If validation is disabled, we still want to do this retag. This is because
-                    // const-eval disables validation for performance reasons but wants to retag
-                    // shared references. So we add a bit of a hack here to do the retag manually
-                    // if the write would not incur validation.
-                    if !M::enforce_validity(ecx, val.layout) {
-                        if let Some(new_val) = M::retag_ptr_value(ecx, &val, val.layout.ty)? {
-                            val = new_val;
-                        }
-                    }
-                    // Now do the actual write.
-                    ecx.write_immediate(*val, &dest)
-                })?;
+                self.write_ref_to_place(place, &dest, mode)?;
             }
 
             Reborrow(target_ty, _, place) => {
@@ -286,6 +271,31 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         interp_ok(())
     }
 
+    fn write_ref_to_place(
+        &mut self,
+        source_place: mir::Place<'tcx>,
+        dest: &PlaceTy<'tcx, M::Provenance>,
+        mode: RetagMode,
+    ) -> InterpResult<'tcx> {
+        let src = self.eval_place(source_place)?;
+        let place = self.force_allocation(&src)?;
+        let mut val = ImmTy::from_immediate(place.to_ref(self), dest.layout);
+        // A fresh reference was created, make sure it gets retagged with the right mode.
+        M::with_retag_mode(self, mode, |ecx| {
+            // If validation is disabled, we still want to do this retag. This is because
+            // const-eval disables validation for performance reasons but wants to retag
+            // shared references. So we add a bit of a hack here to do the retag manually
+            // if the write would not incur validation.
+            if !M::enforce_validity(ecx, val.layout) {
+                if let Some(new_val) = M::retag_ptr_value(ecx, &val, val.layout.ty)? {
+                    val = new_val;
+                }
+            }
+            // Now do the actual write.
+            ecx.write_immediate(*val, dest)
+        })
+    }
+
     fn eval_reborrow_into_place(
         &mut self,
         target_ty: Ty<'tcx>,
@@ -301,6 +311,27 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         let (ty::Adt(source_def, source_args), ty::Adt(target_def, target_args)) =
             (source_ty.kind(), target_ty.kind())
         else {
+            let is_mut_to_shared_ref = if let (
+                ty::Ref(_, source_pointee, Mutability::Mut),
+                ty::Ref(_, target_pointee, Mutability::Not),
+            ) = (source_ty.kind(), target_ty.kind())
+            {
+                util::relate_types(
+                    tcx,
+                    self.typing_env,
+                    ty::Variance::Covariant,
+                    *source_pointee,
+                    *target_pointee,
+                )
+            } else {
+                false
+            };
+            if is_mut_to_shared_ref {
+                let deref_source = source_place.project_deeper(&[mir::ProjectionElem::Deref], tcx);
+                self.write_ref_to_place(deref_source, dest, RetagMode::Default)?;
+                return interp_ok(());
+            }
+
             let op = self.eval_place_to_op(source_place, Some(dest.layout))?;
             self.copy_op(&op, dest)?;
             return interp_ok(());