diff --git a/compiler/rustc_borrowck/src/borrow_set.rs b/compiler/rustc_borrowck/src/borrow_set.rs
index 4644c210137fe..6d68703642314 100644
--- a/compiler/rustc_borrowck/src/borrow_set.rs
+++ b/compiler/rustc_borrowck/src/borrow_set.rs
@@ -2,11 +2,12 @@ use std::fmt;
 use std::ops::Index;
 
 use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};
+use rustc_hir::Mutability;
 use rustc_index::bit_set::DenseBitSet;
 use rustc_middle::mir::visit::{MutatingUseContext, NonUseContext, PlaceContext, Visitor};
 use rustc_middle::mir::{self, Body, Local, Location, traversal};
-use rustc_middle::span_bug;
 use rustc_middle::ty::{RegionVid, TyCtxt};
+use rustc_middle::{bug, span_bug, ty};
 use rustc_mir_dataflow::move_paths::MoveData;
 use tracing::debug;
 
@@ -300,6 +301,50 @@ impl<'a, 'tcx> Visitor<'tcx> for GatherBorrows<'a, 'tcx> {
                 idx
             };
 
+            self.local_map.entry(borrowed_place.local).or_default().insert(idx);
+        } else if let &mir::Rvalue::Reborrow(target, mutability, borrowed_place) = 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!()
+            };
+            let &ty::Adt(target_adt, assigned_args) = target.kind() else { unreachable!() };
+            let Some(ty::GenericArgKind::Lifetime(region)) = assigned_args.get(0).map(|r| r.kind())
+            else {
+                bug!(
+                    "hir-typeck passed but {} does not have a lifetime argument",
+                    if mutability == Mutability::Mut { "Reborrow" } else { "CoerceShared" }
+                );
+            };
+            let region = region.as_var();
+            let kind = if mutability == Mutability::Mut {
+                // Reborrow
+                if target_adt.did() != reborrowed_adt.did() {
+                    bug!(
+                        "hir-typeck passed but Reborrow involves mismatching types at {location:?}"
+                    )
+                }
+
+                mir::BorrowKind::Mut { kind: mir::MutBorrowKind::Default }
+            } else {
+                // CoerceShared
+                if target_adt.did() == reborrowed_adt.did() {
+                    bug!(
+                        "hir-typeck passed but CoerceShared involves matching types at {location:?}"
+                    )
+                }
+                mir::BorrowKind::Shared
+            };
+            let borrow = BorrowData {
+                kind,
+                region,
+                reserve_location: location,
+                activation_location: TwoPhaseActivation::NotTwoPhase,
+                borrowed_place,
+                assigned_place: *assigned_place,
+            };
+            let (idx, _) = self.location_map.insert_full(location, borrow);
+            let idx = BorrowIndex::from(idx);
+
             self.local_map.entry(borrowed_place.local).or_default().insert(idx);
         }
 
diff --git a/compiler/rustc_borrowck/src/dataflow.rs b/compiler/rustc_borrowck/src/dataflow.rs
index 813ceaeb8da9f..4cf903766f5e8 100644
--- 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) = 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
index 822fe1e58ebba..b262eec2c4d72 100644
--- a/compiler/rustc_borrowck/src/lib.rs
+++ b/compiler/rustc_borrowck/src/lib.rs
@@ -1266,6 +1266,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
         let mut error_reported = false;
 
         let borrows_in_scope = self.borrows_in_scope(location, state);
+        debug!(?borrows_in_scope, ?location);
 
         each_borrow_involving_path(
             self,
@@ -1508,6 +1509,36 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
                 );
             }
 
+            &Rvalue::Reborrow(_target, mutability, place) => {
+                let access_kind = (
+                    Deep,
+                    if mutability == Mutability::Mut {
+                        Write(WriteKind::MutableBorrow(BorrowKind::Mut {
+                            kind: MutBorrowKind::Default,
+                        }))
+                    } else {
+                        Read(ReadKind::Borrow(BorrowKind::Shared))
+                    },
+                );
+
+                self.access_place(
+                    location,
+                    (place, span),
+                    access_kind,
+                    LocalMutationIsAllowed::Yes,
+                    state,
+                );
+
+                let action = InitializationRequiringAction::Borrow;
+
+                self.check_if_path_or_subpath_is_moved(
+                    location,
+                    action,
+                    (place.as_ref(), span),
+                    state,
+                );
+            }
+
             &Rvalue::RawPtr(kind, place) => {
                 let access_kind = match kind {
                     RawPtrKind::Mut => (
diff --git a/compiler/rustc_borrowck/src/polonius/legacy/loan_invalidations.rs b/compiler/rustc_borrowck/src/polonius/legacy/loan_invalidations.rs
index 439aa1a91e068..536e0d1863d1f 100644
--- a/compiler/rustc_borrowck/src/polonius/legacy/loan_invalidations.rs
+++ b/compiler/rustc_borrowck/src/polonius/legacy/loan_invalidations.rs
@@ -275,6 +275,21 @@ impl<'a, 'tcx> LoanInvalidationsGenerator<'a, 'tcx> {
                 self.access_place(location, place, access_kind, LocalMutationIsAllowed::No);
             }
 
+            &Rvalue::Reborrow(_target, mutability, place) => {
+                let access_kind = (
+                    Deep,
+                    if mutability == Mutability::Mut {
+                        Reservation(WriteKind::MutableBorrow(BorrowKind::Mut {
+                            kind: MutBorrowKind::TwoPhaseBorrow,
+                        }))
+                    } else {
+                        Read(ReadKind::Borrow(BorrowKind::Shared))
+                    },
+                );
+
+                self.access_place(location, place, access_kind, LocalMutationIsAllowed::No);
+            }
+
             &Rvalue::RawPtr(kind, place) => {
                 let access_kind = match kind {
                     RawPtrKind::Mut => (
diff --git a/compiler/rustc_borrowck/src/type_check/mod.rs b/compiler/rustc_borrowck/src/type_check/mod.rs
index 59874e82e920f..21e0a31cbedd6 100644
--- a/compiler/rustc_borrowck/src/type_check/mod.rs
+++ b/compiler/rustc_borrowck/src/type_check/mod.rs
@@ -1581,6 +1581,15 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                 self.add_reborrow_constraint(location, *region, borrowed_place);
             }
 
+            Rvalue::Reborrow(target, mutability, borrowed_place) => {
+                self.add_generic_reborrow_constraint(
+                    *mutability,
+                    location,
+                    borrowed_place,
+                    *target,
+                );
+            }
+
             Rvalue::BinaryOp(
                 BinOp::Eq | BinOp::Ne | BinOp::Lt | BinOp::Le | BinOp::Gt | BinOp::Ge,
                 box (left, right),
@@ -2219,6 +2228,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
             | Rvalue::ThreadLocalRef(_)
             | Rvalue::Repeat(..)
             | Rvalue::Ref(..)
+            | Rvalue::Reborrow(..)
             | Rvalue::RawPtr(..)
             | Rvalue::Cast(..)
             | Rvalue::BinaryOp(..)
@@ -2423,6 +2433,116 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
         }
     }
 
+    fn add_generic_reborrow_constraint(
+        &mut self,
+        mutability: Mutability,
+        location: Location,
+        borrowed_place: &Place<'tcx>,
+        dest_ty: Ty<'tcx>,
+    ) {
+        let Self { borrow_set, location_table, polonius_facts, constraints, infcx, body, .. } =
+            self;
+
+        debug!(
+            "add_generic_reborrow_constraint({:?}, {:?}, {:?}, {:?})",
+            mutability, location, borrowed_place, dest_ty
+        );
+
+        let tcx = infcx.tcx;
+        let def = body.source.def_id().expect_local();
+        let upvars = tcx.closure_captures(def);
+        let field =
+            path_utils::is_upvar_field_projection(tcx, upvars, borrowed_place.as_ref(), body);
+        let category = if let Some(field) = field {
+            ConstraintCategory::ClosureUpvar(field)
+        } else {
+            ConstraintCategory::Boring
+        };
+
+        let borrowed_ty = borrowed_place.ty(self.body, tcx).ty;
+
+        let ty::Adt(dest_adt, dest_args) = dest_ty.kind() else { bug!() };
+        let [dest_arg, ..] = ***dest_args else { bug!() };
+        let ty::GenericArgKind::Lifetime(dest_region) = dest_arg.kind() else { bug!() };
+        constraints.liveness_constraints.add_location(dest_region.as_var(), location);
+
+        // In Polonius mode, we also push a `loan_issued_at` fact
+        // linking the loan to the region.
+        if let Some(polonius_facts) = polonius_facts {
+            let _prof_timer = infcx.tcx.prof.generic_activity("polonius_fact_generation");
+            if let Some(borrow_index) = borrow_set.get_index_of(&location) {
+                let region_vid = dest_region.as_var();
+                polonius_facts.loan_issued_at.push((
+                    region_vid.into(),
+                    borrow_index,
+                    location_table.mid_index(location),
+                ));
+            }
+        }
+
+        if mutability.is_not() {
+            // FIXME(reborrow): for CoerceShared we need to relate the types manually, field by
+            // field. We cannot just attempt to relate `T` and `<T as CoerceShared>::Target` by
+            // calling relate_types as they are (generally) two unrelated user-defined ADTs, such as
+            // `CustomMut<'a>` and `CustomRef<'a>`, or `CustomMut<'a, T>` and `CustomRef<'a, T>`.
+            // Field-by-field relate_types is expected to work based on the wf-checks that the
+            // CoerceShared trait performs.
+            let ty::Adt(borrowed_adt, borrowed_args) = borrowed_ty.kind() else { unreachable!() };
+            let borrowed_fields = borrowed_adt.all_fields().collect::<Vec<_>>();
+            for dest_field in dest_adt.all_fields() {
+                let Some(borrowed_field) =
+                    borrowed_fields.iter().find(|f| f.name == dest_field.name)
+                else {
+                    continue;
+                };
+                let dest_ty = dest_field.ty(tcx, dest_args);
+                let borrowed_ty = borrowed_field.ty(tcx, borrowed_args);
+                if let (
+                    ty::Ref(borrow_region, _, Mutability::Mut),
+                    ty::Ref(ref_region, _, Mutability::Not),
+                ) = (borrowed_ty.kind(), dest_ty.kind())
+                {
+                    self.relate_types(
+                        borrowed_ty.peel_refs(),
+                        ty::Variance::Covariant,
+                        dest_ty.peel_refs(),
+                        location.to_locations(),
+                        category,
+                    )
+                    .unwrap();
+                    self.constraints.outlives_constraints.push(OutlivesConstraint {
+                        sup: ref_region.as_var(),
+                        sub: borrow_region.as_var(),
+                        locations: location.to_locations(),
+                        span: location.to_locations().span(self.body),
+                        category,
+                        variance_info: ty::VarianceDiagInfo::default(),
+                        from_closure: false,
+                    });
+                } else {
+                    self.relate_types(
+                        borrowed_ty,
+                        ty::Variance::Covariant,
+                        dest_ty,
+                        location.to_locations(),
+                        category,
+                    )
+                    .unwrap();
+                }
+            }
+        } else {
+            // Exclusive reborrow
+            self.relate_types(
+                borrowed_ty,
+                ty::Variance::Covariant,
+                dest_ty,
+                location.to_locations(),
+                category,
+            )
+            .unwrap();
+        }
+    }
+
     fn prove_aggregate_predicates(
         &mut self,
         aggregate_kind: &AggregateKind<'tcx>,
diff --git a/compiler/rustc_codegen_cranelift/src/base.rs b/compiler/rustc_codegen_cranelift/src/base.rs
index 4f483cdc5d6c7..607dcb17908b1 100644
--- a/compiler/rustc_codegen_cranelift/src/base.rs
+++ b/compiler/rustc_codegen_cranelift/src/base.rs
@@ -629,6 +629,11 @@ fn codegen_stmt<'tcx>(fx: &mut FunctionCx<'_, '_, 'tcx>, cur_block: Block, stmt:
                     let ref_ = place.place_ref(fx, lval.layout());
                     lval.write_cvalue(fx, ref_);
                 }
+                Rvalue::Reborrow(_, _, place) => {
+                    let cplace = codegen_place(fx, place);
+                    let val = cplace.to_cvalue(fx);
+                    lval.write_cvalue(fx, val)
+                }
                 Rvalue::ThreadLocalRef(def_id) => {
                     let val = crate::constant::codegen_tls_ref(fx, def_id, lval.layout());
                     lval.write_cvalue(fx, val);
diff --git a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
index f9e4a6a352bac..52493ecb3eb70 100644
--- a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
@@ -518,6 +518,14 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 self.codegen_place_to_pointer(bx, place, mk_ref)
             }
 
+            // Note: Exclusive reborrowing is always equal to a memcpy, as the types do not change.
+            // 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::RawPtr(kind, place) => {
                 let mk_ptr = move |tcx: TyCtxt<'tcx>, ty: Ty<'tcx>| {
                     Ty::new_ptr(tcx, ty, kind.to_mutbl_lossy())
diff --git a/compiler/rustc_const_eval/src/check_consts/check.rs b/compiler/rustc_const_eval/src/check_consts/check.rs
index 3869596cce300..3d5ed30d59ebe 100644
--- a/compiler/rustc_const_eval/src/check_consts/check.rs
+++ b/compiler/rustc_const_eval/src/check_consts/check.rs
@@ -610,6 +610,10 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
                 }
             }
 
+            Rvalue::Reborrow(..) => {
+                // FIXME(reborrow): figure out if this is relevant at all.
+            }
+
             Rvalue::RawPtr(RawPtrKind::FakeForPtrMetadata, place) => {
                 // These are only inserted for slice length, so the place must already be indirect.
                 // This implies we do not have to worry about whether the borrow escapes.
diff --git a/compiler/rustc_const_eval/src/check_consts/qualifs.rs b/compiler/rustc_const_eval/src/check_consts/qualifs.rs
index a4f33ea05b2d3..a82728b043baa 100644
--- a/compiler/rustc_const_eval/src/check_consts/qualifs.rs
+++ b/compiler/rustc_const_eval/src/check_consts/qualifs.rs
@@ -252,6 +252,8 @@ where
             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),
 
         Rvalue::Aggregate(kind, operands) => {
diff --git a/compiler/rustc_const_eval/src/check_consts/resolver.rs b/compiler/rustc_const_eval/src/check_consts/resolver.rs
index 044b8b091b8de..a230f797b56fd 100644
--- a/compiler/rustc_const_eval/src/check_consts/resolver.rs
+++ b/compiler/rustc_const_eval/src/check_consts/resolver.rs
@@ -191,6 +191,19 @@ where
                 }
             }
 
+            mir::Rvalue::Reborrow(target, mutability, borrowed_place) => {
+                // A Reborrow allows mutation if it is Reborrow or if the CoerceShared target isn't
+                // Freeze.
+                if !borrowed_place.is_indirect()
+                    && (mutability.is_mut() || !target.is_freeze(self.ccx.tcx, self.ccx.typing_env))
+                {
+                    if Q::in_any_value_of_ty(self.ccx, *target) {
+                        self.state.qualif.insert(borrowed_place.local);
+                        self.state.borrow.insert(borrowed_place.local);
+                    }
+                }
+            }
+
             mir::Rvalue::Cast(..)
             | mir::Rvalue::Use(..)
             | mir::Rvalue::CopyForDeref(..)
diff --git a/compiler/rustc_const_eval/src/interpret/step.rs b/compiler/rustc_const_eval/src/interpret/step.rs
index f9ab86e9888d7..4f61f5be320c4 100644
--- a/compiler/rustc_const_eval/src/interpret/step.rs
+++ b/compiler/rustc_const_eval/src/interpret/step.rs
@@ -228,6 +228,11 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 self.write_immediate(*val, &dest)?;
             }
 
+            Reborrow(_, _, place) => {
+                let op = self.eval_place_to_op(place, Some(dest.layout))?;
+                self.copy_op(&op, &dest)?;
+            }
+
             RawPtr(kind, place) => {
                 // Figure out whether this is an addr_of of an already raw place.
                 let place_base_raw = if place.is_indirect_first_projection() {
diff --git a/compiler/rustc_hir/src/lang_items.rs b/compiler/rustc_hir/src/lang_items.rs
index 6a8e5d25e54cc..359b3e9400e30 100644
--- a/compiler/rustc_hir/src/lang_items.rs
+++ b/compiler/rustc_hir/src/lang_items.rs
@@ -436,7 +436,7 @@ language_item_table! {
 
     // Reborrowing related lang-items
     Reborrow,                sym::reborrow,            reborrow,                   Target::Trait,          GenericRequirement::Exact(0);
-    CoerceShared,            sym::coerce_shared,       coerce_shared,              Target::Trait,          GenericRequirement::Exact(0);
+    CoerceShared,            sym::coerce_shared,       coerce_shared,              Target::Trait,          GenericRequirement::Exact(1);
 
     // Field representing types.
     FieldRepresentingType,   sym::field_representing_type, field_representing_type,    Target::Struct,         GenericRequirement::Exact(3);
diff --git a/compiler/rustc_hir_analysis/src/coherence/builtin.rs b/compiler/rustc_hir_analysis/src/coherence/builtin.rs
index 4a10bde4d6da3..5d9a7a8dfe8d6 100644
--- a/compiler/rustc_hir_analysis/src/coherence/builtin.rs
+++ b/compiler/rustc_hir_analysis/src/coherence/builtin.rs
@@ -9,10 +9,11 @@ use rustc_hir as hir;
 use rustc_hir::ItemKind;
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_hir::lang_items::LangItem;
-use rustc_infer::infer::{self, RegionResolutionError, SubregionOrigin, TyCtxtInferExt};
+use rustc_infer::infer::{self, InferCtxt, RegionResolutionError, SubregionOrigin, TyCtxtInferExt};
 use rustc_infer::traits::Obligation;
 use rustc_middle::ty::adjustment::CoerceUnsizedInfo;
 use rustc_middle::ty::print::PrintTraitRefExt as _;
+use rustc_middle::ty::relate::solver_relating::RelateExt;
 use rustc_middle::ty::{
     self, Ty, TyCtxt, TypeVisitableExt, TypingMode, suggest_constraining_type_params,
 };
@@ -22,7 +23,7 @@ use rustc_trait_selection::traits::misc::{
     ConstParamTyImplementationError, CopyImplementationError, InfringingFieldsReason,
     type_allowed_to_implement_const_param_ty, type_allowed_to_implement_copy,
 };
-use rustc_trait_selection::traits::{self, ObligationCause, ObligationCtxt};
+use rustc_trait_selection::traits::{self, FulfillmentError, ObligationCause, ObligationCtxt};
 use tracing::debug;
 
 use crate::errors;
@@ -43,6 +44,8 @@ pub(super) fn check_trait<'tcx>(
         visit_implementation_of_const_param_ty(checker)
     })?;
     checker.check(lang_items.coerce_unsized_trait(), visit_implementation_of_coerce_unsized)?;
+    checker.check(lang_items.reborrow(), visit_implementation_of_reborrow)?;
+    checker.check(lang_items.coerce_shared(), visit_implementation_of_coerce_shared)?;
     checker
         .check(lang_items.dispatch_from_dyn_trait(), visit_implementation_of_dispatch_from_dyn)?;
     checker.check(
@@ -255,6 +258,28 @@ fn visit_implementation_of_coerce_unsized(checker: &Checker<'_>) -> Result<(), E
     tcx.ensure_result().coerce_unsized_info(impl_did)
 }
 
+fn visit_implementation_of_reborrow(checker: &Checker<'_>) -> Result<(), ErrorGuaranteed> {
+    let tcx = checker.tcx;
+    let impl_did = checker.impl_def_id;
+    debug!("visit_implementation_of_reborrow: impl_did={:?}", impl_did);
+
+    // Just compute this for the side-effects, in particular reporting
+    // errors; other parts of the code may demand it for the info of
+    // course.
+    reborrow_info(tcx, impl_did)
+}
+
+fn visit_implementation_of_coerce_shared(checker: &Checker<'_>) -> Result<(), ErrorGuaranteed> {
+    let tcx = checker.tcx;
+    let impl_did = checker.impl_def_id;
+    debug!("visit_implementation_of_coerce_shared: impl_did={:?}", impl_did);
+
+    // Just compute this for the side-effects, in particular reporting
+    // errors; other parts of the code may demand it for the info of
+    // course.
+    coerce_shared_info(tcx, impl_did)
+}
+
 fn is_from_coerce_pointee_derive(tcx: TyCtxt<'_>, span: Span) -> bool {
     span.ctxt()
         .outer_expn_data()
@@ -440,6 +465,288 @@ fn visit_implementation_of_dispatch_from_dyn(checker: &Checker<'_>) -> Result<()
     }
 }
 
+pub(crate) fn reborrow_info<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    impl_did: LocalDefId,
+) -> Result<(), ErrorGuaranteed> {
+    debug!("compute_reborrow_info(impl_did={:?})", impl_did);
+    let infcx = tcx.infer_ctxt().build(TypingMode::non_body_analysis());
+    let span = tcx.def_span(impl_did);
+    let trait_name = "Reborrow";
+
+    let reborrow_trait = tcx.require_lang_item(LangItem::Reborrow, span);
+
+    let source = tcx.type_of(impl_did).instantiate_identity().skip_norm_wip();
+    let trait_ref = tcx.impl_trait_ref(impl_did).instantiate_identity().skip_norm_wip();
+
+    if trait_impl_lifetime_params_count(tcx, impl_did) != 1 {
+        return Err(tcx
+            .dcx()
+            .emit_err(errors::CoerceSharedNotSingleLifetimeParam { span, trait_name }));
+    }
+
+    assert_eq!(trait_ref.def_id, reborrow_trait);
+    let param_env = tcx.param_env(impl_did);
+    assert!(!source.has_escaping_bound_vars());
+
+    let (def, args) = match source.kind() {
+        &ty::Adt(def, args) if def.is_struct() => (def, args),
+        _ => {
+            // Note: reusing error here as it takes trait_name as argument.
+            return Err(tcx.dcx().emit_err(errors::CoerceUnsizedNonStruct { span, trait_name }));
+        }
+    };
+
+    let lifetimes_count = generic_lifetime_params_count(args);
+    let data_fields = collect_struct_data_fields(tcx, def, args);
+
+    if lifetimes_count != 1 {
+        let item = tcx.hir_expect_item(impl_did);
+        let _span = if let ItemKind::Impl(hir::Impl { of_trait: Some(of_trait), .. }) = &item.kind {
+            of_trait.trait_ref.path.span
+        } else {
+            tcx.def_span(impl_did)
+        };
+
+        return Err(tcx.dcx().emit_err(errors::CoerceSharedMulti { span, trait_name }));
+    }
+
+    if data_fields.is_empty() {
+        return Ok(());
+    }
+
+    // We've found some data fields. They must all be either be Copy or Reborrow.
+    for (field, span) in data_fields {
+        if assert_field_type_is_reborrow(
+            tcx,
+            &infcx,
+            reborrow_trait,
+            impl_did,
+            param_env,
+            field,
+            span,
+        )
+        .is_ok()
+        {
+            // Field implements Reborrow.
+            return Ok(());
+        }
+
+        // Field does not implement Reborrow: it must be Copy.
+        assert_field_type_is_copy(tcx, &infcx, impl_did, param_env, field, span)?;
+    }
+
+    Ok(())
+}
+
+fn assert_field_type_is_reborrow<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    infcx: &InferCtxt<'tcx>,
+    reborrow_trait: DefId,
+    impl_did: LocalDefId,
+    param_env: ty::ParamEnv<'tcx>,
+    ty: Ty<'tcx>,
+    span: Span,
+) -> Result<(), Vec<FulfillmentError<'tcx>>> {
+    if ty.ref_mutability() == Some(ty::Mutability::Mut) {
+        // Mutable references are Reborrow but not really.
+        return Ok(());
+    }
+    let ocx = ObligationCtxt::new_with_diagnostics(infcx);
+    let cause = traits::ObligationCause::misc(span, impl_did);
+    let obligation =
+        Obligation::new(tcx, cause, param_env, ty::TraitRef::new(tcx, reborrow_trait, [ty]));
+    ocx.register_obligation(obligation);
+    let errors = ocx.evaluate_obligations_error_on_ambiguity();
+
+    if !errors.is_empty() { Err(errors) } else { Ok(()) }
+}
+
+pub(crate) fn coerce_shared_info<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    impl_did: LocalDefId,
+) -> Result<(), ErrorGuaranteed> {
+    debug!("compute_coerce_shared_info(impl_did={:?})", impl_did);
+    let infcx = tcx.infer_ctxt().build(TypingMode::non_body_analysis());
+    let span = tcx.def_span(impl_did);
+    let trait_name = "CoerceShared";
+
+    let coerce_shared_trait = tcx.require_lang_item(LangItem::CoerceShared, span);
+
+    let source = tcx.type_of(impl_did).instantiate_identity().skip_norm_wip();
+    let trait_ref = tcx.impl_trait_ref(impl_did).instantiate_identity().skip_norm_wip();
+
+    if trait_impl_lifetime_params_count(tcx, impl_did) != 1 {
+        return Err(tcx
+            .dcx()
+            .emit_err(errors::CoerceSharedNotSingleLifetimeParam { span, trait_name }));
+    }
+
+    assert_eq!(trait_ref.def_id, coerce_shared_trait);
+    let target = trait_ref.args.type_at(1);
+
+    let param_env = tcx.param_env(impl_did);
+    assert!(!source.has_escaping_bound_vars());
+
+    let data = match (source.kind(), target.kind()) {
+        (&ty::Adt(def_a, args_a), &ty::Adt(def_b, args_b))
+            if def_a.is_struct() && def_b.is_struct() =>
+        {
+            // Check that both A and B have exactly one lifetime argument, and that they have the
+            // same number of data fields that is not more than 1. The eventual intention is to
+            // support multiple lifetime arguments (with the reborrowed lifetimes inferred from
+            // usage one way or another) and multiple data fields with B allowed to leave out fields
+            // from A. The current state is just the simplest choice.
+            let a_lifetimes_count = generic_lifetime_params_count(args_a);
+            let a_data_fields = collect_struct_data_fields(tcx, def_a, args_a);
+            let b_lifetimes_count = generic_lifetime_params_count(args_b);
+            let b_data_fields = collect_struct_data_fields(tcx, def_b, args_b);
+
+            if a_lifetimes_count != 1
+                || b_lifetimes_count != 1
+                || a_data_fields.len() > 1
+                || b_data_fields.len() > 1
+                || a_data_fields.len() != b_data_fields.len()
+            {
+                let item = tcx.hir_expect_item(impl_did);
+                let span = if let ItemKind::Impl(hir::Impl { of_trait: Some(of_trait), .. }) =
+                    &item.kind
+                {
+                    of_trait.trait_ref.path.span
+                } else {
+                    tcx.def_span(impl_did)
+                };
+
+                return Err(tcx.dcx().emit_err(errors::CoerceSharedMulti { span, trait_name }));
+            }
+
+            if a_data_fields.len() == 1 {
+                // We found one data field for both: we'll attempt to perform CoerceShared between
+                // them below.
+                let (a, span_a) = a_data_fields[0];
+                let (b, span_b) = b_data_fields[0];
+
+                Some((a, b, coerce_shared_trait, span_a, span_b))
+            } else {
+                // We found no data fields in either: this is a reborrowable marker type being
+                // coerced into a shared marker. That is fine too.
+                None
+            }
+        }
+
+        _ => {
+            // Note: reusing CoerceUnsizedNonStruct error as it takes trait_name as argument.
+            return Err(tcx.dcx().emit_err(errors::CoerceUnsizedNonStruct { span, trait_name }));
+        }
+    };
+
+    // We've proven that we have two types with one lifetime each and 0 or 1 data fields each.
+    if let Some((source, target, trait_def_id, source_field_span, _target_field_span)) = data {
+        // struct Source(SourceData);
+        // struct Target(TargetData);
+        //
+        // 1 data field each; they must be the same type and Copy, or relate to one another using
+        // CoerceShared.
+        if source.ref_mutability() == Some(ty::Mutability::Mut)
+            && target.ref_mutability() == Some(ty::Mutability::Not)
+            && infcx
+                .eq_structurally_relating_aliases(
+                    param_env,
+                    source.peel_refs(),
+                    target.peel_refs(),
+                    source_field_span,
+                )
+                .is_ok()
+        {
+            // &mut T implements CoerceShared to &T, except not really.
+            return Ok(());
+        }
+        if infcx
+            .eq_structurally_relating_aliases(param_env, source, target, source_field_span)
+            .is_err()
+        {
+            // The two data fields don't agree on a common type; this means
+            // that they must be `A: CoerceShared<B>`. Register an obligation
+            // for that.
+            let ocx = ObligationCtxt::new_with_diagnostics(&infcx);
+            let cause = traits::ObligationCause::misc(span, impl_did);
+            let obligation = Obligation::new(
+                tcx,
+                cause,
+                param_env,
+                ty::TraitRef::new(tcx, trait_def_id, [source, target]),
+            );
+            ocx.register_obligation(obligation);
+            let errors = ocx.evaluate_obligations_error_on_ambiguity();
+
+            if !errors.is_empty() {
+                return Err(infcx.err_ctxt().report_fulfillment_errors(errors));
+            }
+            // Finally, resolve all regions.
+            ocx.resolve_regions_and_report_errors(impl_did, param_env, [])?;
+        } else {
+            // Types match: check that it is Copy.
+            assert_field_type_is_copy(tcx, &infcx, impl_did, param_env, source, source_field_span)?;
+        }
+    }
+
+    Ok(())
+}
+
+fn trait_impl_lifetime_params_count(tcx: TyCtxt<'_>, did: LocalDefId) -> usize {
+    tcx.generics_of(did)
+        .own_params
+        .iter()
+        .filter(|p| matches!(p.kind, ty::GenericParamDefKind::Lifetime))
+        .count()
+}
+
+fn generic_lifetime_params_count(args: &[ty::GenericArg<'_>]) -> usize {
+    args.iter().filter(|arg| arg.as_region().is_some()).count()
+}
+
+fn collect_struct_data_fields<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    def: ty::AdtDef<'tcx>,
+    args: ty::GenericArgsRef<'tcx>,
+) -> Vec<(Ty<'tcx>, Span)> {
+    def.non_enum_variant()
+        .fields
+        .iter()
+        .filter_map(|f| {
+            // Ignore PhantomData fields
+            let ty = f.ty(tcx, args);
+            if ty.is_phantom_data() {
+                return None;
+            }
+            Some((ty, tcx.def_span(f.did)))
+        })
+        .collect()
+}
+
+fn assert_field_type_is_copy<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    infcx: &InferCtxt<'tcx>,
+    impl_did: LocalDefId,
+    param_env: ty::ParamEnv<'tcx>,
+    ty: Ty<'tcx>,
+    span: Span,
+) -> Result<(), ErrorGuaranteed> {
+    let copy_trait = tcx.require_lang_item(LangItem::Copy, span);
+    let ocx = ObligationCtxt::new_with_diagnostics(infcx);
+    let cause = traits::ObligationCause::misc(span, impl_did);
+    let obligation =
+        Obligation::new(tcx, cause, param_env, ty::TraitRef::new(tcx, copy_trait, [ty]));
+    ocx.register_obligation(obligation);
+    let errors = ocx.evaluate_obligations_error_on_ambiguity();
+
+    if !errors.is_empty() {
+        Err(infcx.err_ctxt().report_fulfillment_errors(errors))
+    } else {
+        Ok(())
+    }
+}
+
 pub(crate) fn coerce_unsized_info<'tcx>(
     tcx: TyCtxt<'tcx>,
     impl_did: LocalDefId,
diff --git a/compiler/rustc_hir_analysis/src/errors.rs b/compiler/rustc_hir_analysis/src/errors.rs
index 1bb54f27dcbdd..e0528a3e3b49c 100644
--- a/compiler/rustc_hir_analysis/src/errors.rs
+++ b/compiler/rustc_hir_analysis/src/errors.rs
@@ -1358,6 +1358,24 @@ pub(crate) struct CoerceMulti {
     pub fields: MultiSpan,
 }
 
+#[derive(Diagnostic)]
+#[diag(
+    "implementing `{$trait_name}` requires that a single lifetime parameter is passed between source and target"
+)]
+pub(crate) struct CoerceSharedNotSingleLifetimeParam {
+    #[primary_span]
+    pub span: Span,
+    pub trait_name: &'static str,
+}
+
+#[derive(Diagnostic)]
+#[diag("implementing `{$trait_name}` does not allow multiple lifetimes or fields to be coerced")]
+pub(crate) struct CoerceSharedMulti {
+    #[primary_span]
+    pub span: Span,
+    pub trait_name: &'static str,
+}
+
 #[derive(Diagnostic)]
 #[diag("the trait `{$trait_name}` may only be implemented for a coercion between structures", code = E0377)]
 pub(crate) struct CoerceUnsizedNonStruct {
diff --git a/compiler/rustc_hir_typeck/src/coercion.rs b/compiler/rustc_hir_typeck/src/coercion.rs
index 0a13d6c97e7c3..72a6f27e9a48c 100644
--- a/compiler/rustc_hir_typeck/src/coercion.rs
+++ b/compiler/rustc_hir_typeck/src/coercion.rs
@@ -283,7 +283,8 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
         }
 
         // Examine the target type and consider type-specific coercions, such
-        // as auto-borrowing, coercing pointer mutability, or pin-ergonomics.
+        // as auto-borrowing, coercing pointer mutability, pin-ergonomics, or
+        // generic reborrow.
         match *b.kind() {
             ty::RawPtr(_, b_mutbl) => {
                 return self.coerce_to_raw_ptr(a, b, b_mutbl);
@@ -297,6 +298,26 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
             _ if let Some(to_pin_ref) = self.maybe_to_pin_ref(a, b) => {
                 return self.coerce_to_pin_ref(to_pin_ref);
             }
+            ty::Adt(_, _)
+                if self.tcx.features().reborrow()
+                    && self
+                        .fcx
+                        .infcx
+                        .type_implements_trait(
+                            self.tcx
+                                .lang_items()
+                                .reborrow()
+                                .expect("Unexpectedly using core/std without reborrow"),
+                            [b],
+                            self.fcx.param_env,
+                        )
+                        .must_apply_modulo_regions() =>
+            {
+                let reborrow_coerce = self.commit_if_ok(|_| self.coerce_reborrow(a, b));
+                if reborrow_coerce.is_ok() {
+                    return reborrow_coerce;
+                }
+            }
             _ => {}
         }
 
@@ -320,6 +341,14 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
                 // It cannot convert closures that require unsafe.
                 self.coerce_closure_to_fn(a, b)
             }
+            ty::Adt(_, _) if self.tcx.features().reborrow() => {
+                let reborrow_coerce = self.commit_if_ok(|_| self.coerce_shared_reborrow(a, b));
+                if reborrow_coerce.is_ok() {
+                    reborrow_coerce
+                } else {
+                    self.unify(a, b, ForceLeakCheck::No)
+                }
+            }
             _ => {
                 // Otherwise, just use unification rules.
                 self.unify(a, b, ForceLeakCheck::No)
@@ -934,6 +963,74 @@ impl<'f, 'tcx> Coerce<'f, 'tcx> {
         Ok(coerce)
     }
 
+    /// Applies generic exclusive reborrowing on type implementing `Reborrow`.
+    #[instrument(skip(self), level = "trace")]
+    fn coerce_reborrow(&self, a: Ty<'tcx>, b: Ty<'tcx>) -> CoerceResult<'tcx> {
+        debug_assert!(self.shallow_resolve(a) == a);
+        debug_assert!(self.shallow_resolve(b) == b);
+
+        // We need to make sure the two types are compatible for reborrow.
+        let (ty::Adt(a_def, _), ty::Adt(b_def, _)) = (a.kind(), b.kind()) else {
+            return Err(TypeError::Mismatch);
+        };
+        if a_def.did() == b_def.did() {
+            // Reborrow is applicable here
+            self.unify_and(
+                a,
+                b,
+                [],
+                Adjust::GenericReborrow(ty::Mutability::Mut),
+                ForceLeakCheck::No,
+            )
+        } else {
+            // FIXME: CoerceShared check goes here, error for now
+            Err(TypeError::Mismatch)
+        }
+    }
+
+    /// Applies generic exclusive reborrowing on type implementing `Reborrow`.
+    #[instrument(skip(self), level = "trace")]
+    fn coerce_shared_reborrow(&self, a: Ty<'tcx>, b: Ty<'tcx>) -> CoerceResult<'tcx> {
+        debug_assert!(self.shallow_resolve(a) == a);
+        debug_assert!(self.shallow_resolve(b) == b);
+
+        // We need to make sure the two types are compatible for reborrow.
+        let (ty::Adt(a_def, _), ty::Adt(b_def, _)) = (a.kind(), b.kind()) else {
+            return Err(TypeError::Mismatch);
+        };
+        if a_def.did() == b_def.did() {
+            // CoerceShared cannot be T -> T.
+            return Err(TypeError::Mismatch);
+        }
+        let Some(coerce_shared_trait_did) = self.tcx.lang_items().coerce_shared() else {
+            return Err(TypeError::Mismatch);
+        };
+        let coerce_shared_trait_ref = ty::TraitRef::new(self.tcx, coerce_shared_trait_did, [a, b]);
+        let obligation = traits::Obligation::new(
+            self.tcx,
+            ObligationCause::dummy(),
+            self.param_env,
+            ty::Binder::dummy(coerce_shared_trait_ref),
+        );
+        let ocx = ObligationCtxt::new(&self.infcx);
+        ocx.register_obligation(obligation);
+        let errs = ocx.evaluate_obligations_error_on_ambiguity();
+        if errs.is_empty() {
+            Ok(InferOk {
+                value: (
+                    vec![Adjustment {
+                        kind: Adjust::GenericReborrow(ty::Mutability::Not),
+                        target: b,
+                    }],
+                    b,
+                ),
+                obligations: ocx.into_pending_obligations(),
+            })
+        } else {
+            Err(TypeError::Mismatch)
+        }
+    }
+
     fn coerce_from_fn_pointer(
         &self,
         a: Ty<'tcx>,
diff --git a/compiler/rustc_hir_typeck/src/expr_use_visitor.rs b/compiler/rustc_hir_typeck/src/expr_use_visitor.rs
index a6129d97a328a..010f96f85a22b 100644
--- a/compiler/rustc_hir_typeck/src/expr_use_visitor.rs
+++ b/compiler/rustc_hir_typeck/src/expr_use_visitor.rs
@@ -751,6 +751,15 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
                 adjustment::Adjust::Borrow(ref autoref) => {
                     self.walk_autoref(expr, &place_with_id, autoref);
                 }
+
+                adjustment::Adjust::GenericReborrow(_reborrow) => {
+                    // To build an expression as a place expression, it needs to be a field
+                    // projection or deref at the outmost layer. So it is field projection or deref
+                    // on an adjusted value. But this means that adjustment is applied on a
+                    // subexpression that is not the final operand/rvalue for function call or
+                    // assignment. This is a contradiction.
+                    unreachable!("Reborrow trait usage during adjustment walk");
+                }
             }
             place_with_id = self.cat_expr_adjusted(expr, place_with_id, adjustment)?;
         }
@@ -1282,7 +1291,8 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
 
             adjustment::Adjust::NeverToAny
             | adjustment::Adjust::Pointer(_)
-            | adjustment::Adjust::Borrow(_) => {
+            | adjustment::Adjust::Borrow(_)
+            | adjustment::Adjust::GenericReborrow(..) => {
                 // Result is an rvalue.
                 Ok(self.cat_rvalue(expr.hir_id, target))
             }
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
index 9a54d651fe73a..c331ec4fc15f1 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
@@ -343,6 +343,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 Adjust::Pointer(_pointer_coercion) => {
                     // FIXME(const_trait_impl): We should probably enforce these.
                 }
+                Adjust::GenericReborrow(_) => {
+                    // FIXME(reborrow): figure out if we have effects to enforce here.
+                }
                 Adjust::Borrow(_) => {
                     // No effects to enforce here.
                 }
diff --git a/compiler/rustc_lint/src/autorefs.rs b/compiler/rustc_lint/src/autorefs.rs
index 9a374488ab6fa..24759f3ee4a01 100644
--- a/compiler/rustc_lint/src/autorefs.rs
+++ b/compiler/rustc_lint/src/autorefs.rs
@@ -173,6 +173,7 @@ fn has_implicit_borrow(Adjustment { kind, .. }: &Adjustment<'_>) -> Option<(Muta
         Adjust::NeverToAny
         | Adjust::Pointer(..)
         | Adjust::Deref(DerefAdjustKind::Builtin | DerefAdjustKind::Pin)
+        | Adjust::GenericReborrow(..)
         | Adjust::Borrow(AutoBorrow::RawPtr(..) | AutoBorrow::Pin(..)) => None,
     }
 }
diff --git a/compiler/rustc_middle/src/mir/pretty.rs b/compiler/rustc_middle/src/mir/pretty.rs
index c59e6b6fa2151..27d0f4a1b5ca2 100644
--- a/compiler/rustc_middle/src/mir/pretty.rs
+++ b/compiler/rustc_middle/src/mir/pretty.rs
@@ -1136,6 +1136,14 @@ impl<'tcx> Debug for Rvalue<'tcx> {
                 write!(fmt, "&{region}{kind_str}{place:?}")
             }
 
+            Reborrow(target, mutability, ref place) => {
+                write!(
+                    fmt,
+                    "{target:?}({} {place:?})",
+                    if mutability.is_mut() { "reborrow" } else { "coerce shared" }
+                )
+            }
+
             CopyForDeref(ref place) => write!(fmt, "deref_copy {place:#?}"),
 
             RawPtr(mutability, ref place) => {
diff --git a/compiler/rustc_middle/src/mir/statement.rs b/compiler/rustc_middle/src/mir/statement.rs
index c55d49c12b4b8..a7c863784d575 100644
--- a/compiler/rustc_middle/src/mir/statement.rs
+++ b/compiler/rustc_middle/src/mir/statement.rs
@@ -761,6 +761,7 @@ impl<'tcx> Rvalue<'tcx> {
             | Rvalue::CopyForDeref(_)
             | Rvalue::Repeat(_, _)
             | Rvalue::Ref(_, _, _)
+            | Rvalue::Reborrow(_, _, _)
             | Rvalue::ThreadLocalRef(_)
             | Rvalue::RawPtr(_, _)
             | Rvalue::Cast(
@@ -785,6 +786,12 @@ impl<'tcx> Rvalue<'tcx> {
         }
     }
 
+    /// Returns true if rvalue is a generic Reborrow coercion (usage of Reborrow or CoerceShared
+    /// trait).
+    pub fn is_generic_reborrow(&self) -> bool {
+        matches!(self, Self::Reborrow(..))
+    }
+
     pub fn ty<D>(&self, local_decls: &D, tcx: TyCtxt<'tcx>) -> Ty<'tcx>
     where
         D: ?Sized + HasLocalDecls<'tcx>,
@@ -799,6 +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(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
index 455089f285d17..d0e24d2f71e21 100644
--- a/compiler/rustc_middle/src/mir/syntax.rs
+++ b/compiler/rustc_middle/src/mir/syntax.rs
@@ -1471,6 +1471,25 @@ pub enum Rvalue<'tcx> {
 
     /// Wraps a value in an unsafe binder.
     WrapUnsafeBinder(Operand<'tcx>, Ty<'tcx>),
+
+    /// Creates a bitwise copy of the indicated place with the same type (if Mut) or its
+    /// CoerceShared target type (if Not). The type is known to be an ADT with exactly one lifetime
+    /// parameter, and it is known to implement the Reborrow trait (for Mut), and the CoerceShared
+    /// trait (only if Not). The CoerceShared target type is known to also have exactly one lifetime
+    /// parameter, implement Copy and (currently) have the same memory layout as the source type.
+    ///
+    /// The borrow checker uses the single lifetime in the source and target types to create a
+    /// Covariant outlives-bound between the source and target with the Mutability of the Reborrow.
+    /// This makes accessing the source value for writes (and reads if Mut) for the lifetime of the
+    /// target value a borrow check error, imitating `&mut T` and `&T`'s reborrowing on user ADTs.
+    ///
+    /// Future work may add support for multiple lifetimes and changing memory layout as part of
+    /// CoerceShared. These may be end up implemented as multiple MIR operations.
+    ///
+    /// This is produced by the [`ExprKind::Reborrow`].
+    ///
+    /// [`ExprKind::Reborrow`]: crate::thir::ExprKind::Reborrow
+    Reborrow(Ty<'tcx>, Mutability, Place<'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
index 16a8743a6d67b..e13622e53b4df 100644
--- a/compiler/rustc_middle/src/mir/visit.rs
+++ b/compiler/rustc_middle/src/mir/visit.rs
@@ -730,6 +730,18 @@ macro_rules! make_mir_visitor {
                         self.visit_place(path, ctx, location);
                     }
 
+                    Rvalue::Reborrow(target, mutability, place) => {
+                        self.visit_ty($(& $mutability)? *target, TyContext::Location(location));
+                        self.visit_place(
+                            place,
+                            match mutability {
+                                Mutability::Not => PlaceContext::NonMutatingUse(NonMutatingUseContext::SharedBorrow),
+                                Mutability::Mut => PlaceContext::MutatingUse(MutatingUseContext::Borrow),
+                            },
+                            location
+                        );
+                    }
+
                     Rvalue::CopyForDeref(place) => {
                         self.visit_place(
                             place,
@@ -814,6 +826,8 @@ macro_rules! make_mir_visitor {
                         self.visit_operand(op, location);
                         self.visit_ty($(& $mutability)? *ty, TyContext::Location(location));
                     }
+
+
                 }
             }
 
diff --git a/compiler/rustc_middle/src/thir.rs b/compiler/rustc_middle/src/thir.rs
index 51f33691bb7dd..2ee87d1089b04 100644
--- a/compiler/rustc_middle/src/thir.rs
+++ b/compiler/rustc_middle/src/thir.rs
@@ -546,6 +546,18 @@ pub enum ExprKind<'tcx> {
     Yield {
         value: ExprId,
     },
+    /// Use of an ADT that implements the Reborrow (for Mut) or CoerceShared traits (for Not). This
+    /// expression is produced by the [`Adjust::GenericReborrow`] in places where normally the ADT
+    /// would be moved or assigned over. Instead, this produces an [`Rvalue::Reborrow`] which
+    /// produces a bitwise copy of the source ADT and disables the source for the copy's lifetime.
+    ///
+    /// [`Adjust::GenericReborrow`]: crate::ty::adjustment::Adjust::GenericReborrow
+    /// [`Rvalue::Reborrow`]: mir::Rvalue::Reborrow
+    Reborrow {
+        source: ExprId,
+        mutability: Mutability,
+        target: Ty<'tcx>,
+    },
 }
 
 /// Represents the association of a field identifier and an expression.
diff --git a/compiler/rustc_middle/src/thir/visit.rs b/compiler/rustc_middle/src/thir/visit.rs
index aa1b6b1663bfd..3361e43b15dd9 100644
--- a/compiler/rustc_middle/src/thir/visit.rs
+++ b/compiler/rustc_middle/src/thir/visit.rs
@@ -187,6 +187,7 @@ pub fn walk_expr<'thir, 'tcx: 'thir, V: Visitor<'thir, 'tcx>>(
         }
         ThreadLocalRef(_) => {}
         Yield { value } => visitor.visit_expr(&visitor.thir()[value]),
+        Reborrow { .. } => {}
     }
 }
 
diff --git a/compiler/rustc_middle/src/ty/adjustment.rs b/compiler/rustc_middle/src/ty/adjustment.rs
index 3802bde088a54..ff798c3e3cc45 100644
--- a/compiler/rustc_middle/src/ty/adjustment.rs
+++ b/compiler/rustc_middle/src/ty/adjustment.rs
@@ -103,6 +103,14 @@ pub enum Adjust {
     Borrow(AutoBorrow),
 
     Pointer(PointerCoercion),
+
+    /// Take a user-type T implementing the Reborrow trait (for Mut) or the CoerceShared trait (for
+    /// Not) and reborrow as `T` or `CoreceShared<U>`.
+    ///
+    /// This produces an [`ExprKind::Reborrow`].
+    ///
+    /// [`ExprKind::Reborrow`]: crate::thir::ExprKind::Reborrow
+    GenericReborrow(hir::Mutability),
 }
 
 #[derive(Copy, Clone, Debug, TyEncodable, TyDecodable, HashStable, TypeFoldable, TypeVisitable)]
diff --git a/compiler/rustc_mir_build/src/builder/expr/as_place.rs b/compiler/rustc_mir_build/src/builder/expr/as_place.rs
index b95b565322f18..ff7e518f91a81 100644
--- a/compiler/rustc_mir_build/src/builder/expr/as_place.rs
+++ b/compiler/rustc_mir_build/src/builder/expr/as_place.rs
@@ -590,6 +590,12 @@ 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 { .. } => {
+                // FIXME(reborrow): it should currently be impossible to end up evaluating a
+                // Reborrow expression as a place. That might not in the future, but what this then
+                // evaluates to requires further thought.
+                unreachable!();
+            }
         }
     }
 
diff --git a/compiler/rustc_mir_build/src/builder/expr/as_rvalue.rs b/compiler/rustc_mir_build/src/builder/expr/as_rvalue.rs
index a1b41510f1e1c..47948fc0640fd 100644
--- a/compiler/rustc_mir_build/src/builder/expr/as_rvalue.rs
+++ b/compiler/rustc_mir_build/src/builder/expr/as_rvalue.rs
@@ -431,6 +431,10 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 );
                 block.and(Rvalue::Use(operand))
             }
+            ExprKind::Reborrow { source, mutability, target } => {
+                let temp = unpack!(block = this.as_temp(block, scope, source, mutability));
+                block.and(Rvalue::Reborrow(target, mutability, temp.into()))
+            }
         }
     }
 
diff --git a/compiler/rustc_mir_build/src/builder/expr/category.rs b/compiler/rustc_mir_build/src/builder/expr/category.rs
index 5404d9800c3f5..eb6a0754358d1 100644
--- a/compiler/rustc_mir_build/src/builder/expr/category.rs
+++ b/compiler/rustc_mir_build/src/builder/expr/category.rs
@@ -43,7 +43,8 @@ impl Category {
             | ExprKind::PlaceTypeAscription { .. }
             | ExprKind::ValueTypeAscription { .. }
             | ExprKind::PlaceUnwrapUnsafeBinder { .. }
-            | ExprKind::ValueUnwrapUnsafeBinder { .. } => Some(Category::Place),
+            | ExprKind::ValueUnwrapUnsafeBinder { .. }
+            | ExprKind::Reborrow { .. } => Some(Category::Place),
 
             ExprKind::LogicalOp { .. }
             | ExprKind::Match { .. }
diff --git a/compiler/rustc_mir_build/src/builder/expr/into.rs b/compiler/rustc_mir_build/src/builder/expr/into.rs
index 28109782de2b1..4b6a2fdfbf1af 100644
--- a/compiler/rustc_mir_build/src/builder/expr/into.rs
+++ b/compiler/rustc_mir_build/src/builder/expr/into.rs
@@ -907,6 +907,16 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 this.cfg.push_assign(block, source_info, destination, rvalue);
                 block.unit()
             }
+            ExprKind::Reborrow { source, mutability, target } => {
+                let place = unpack!(block = this.as_place(block, source));
+                this.cfg.push_assign(
+                    block,
+                    source_info,
+                    destination,
+                    Rvalue::Reborrow(target, mutability, place.into()),
+                );
+                block.unit()
+            }
         };
 
         if !expr_is_block_or_scope {
diff --git a/compiler/rustc_mir_build/src/check_unsafety.rs b/compiler/rustc_mir_build/src/check_unsafety.rs
index aed0c6e6085d3..2344ac0e2f739 100644
--- a/compiler/rustc_mir_build/src/check_unsafety.rs
+++ b/compiler/rustc_mir_build/src/check_unsafety.rs
@@ -450,7 +450,8 @@ impl<'a, 'tcx> Visitor<'a, 'tcx> for UnsafetyVisitor<'a, 'tcx> {
             | ExprKind::If { .. }
             | ExprKind::InlineAsm { .. }
             | ExprKind::LogicalOp { .. }
-            | ExprKind::Use { .. } => {
+            | ExprKind::Use { .. }
+            | ExprKind::Reborrow { .. } => {
                 // We don't need to save the old value and restore it
                 // because all the place expressions can't have more
                 // than one child.
diff --git a/compiler/rustc_mir_build/src/thir/cx/expr.rs b/compiler/rustc_mir_build/src/thir/cx/expr.rs
index 69260792a95d2..b32d7dce4f4d3 100644
--- a/compiler/rustc_mir_build/src/thir/cx/expr.rs
+++ b/compiler/rustc_mir_build/src/thir/cx/expr.rs
@@ -221,6 +221,13 @@ impl<'tcx> ThirBuildCx<'tcx> {
                 debug!(?kind);
                 kind
             }
+            Adjust::GenericReborrow(mutability) => {
+                let expr = self.thir.exprs.push(expr);
+                let kind =
+                    ExprKind::Reborrow { source: expr, mutability, target: adjustment.target };
+
+                kind
+            }
         };
 
         Expr { temp_scope_id, ty: adjustment.target, span, 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
index 4dc3e02ace71a..5b786f5a710f8 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
@@ -364,6 +364,12 @@ impl<'p, 'tcx> MatchVisitor<'p, 'tcx> {
             | VarRef { .. }
             | ZstLiteral { .. }
             | Yield { .. } => true,
+            ExprKind::Reborrow { .. } => {
+                // FIXME(reborrow): matching on a Reborrow expression should be impossible
+                // currently. Whether this remains to be true, and if the reborrow result then is a
+                // known valid scrutinee requires further thought.
+                unreachable!("Reborrow expression in match")
+            }
         }
     }
 
diff --git a/compiler/rustc_mir_build/src/thir/print.rs b/compiler/rustc_mir_build/src/thir/print.rs
index ea34e5f4d97df..5330e3397db8e 100644
--- a/compiler/rustc_mir_build/src/thir/print.rs
+++ b/compiler/rustc_mir_build/src/thir/print.rs
@@ -600,6 +600,13 @@ impl<'a, 'tcx> ThirPrinter<'a, 'tcx> {
                 self.print_expr(*value, depth_lvl + 2);
                 print_indented!(self, "}", depth_lvl);
             }
+            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);
+                print_indented!(self, "ty:", depth_lvl + 1);
+                print_indented!(self, "}", depth_lvl);
+            }
         }
     }
 
diff --git a/compiler/rustc_mir_dataflow/src/impls/borrowed_locals.rs b/compiler/rustc_mir_dataflow/src/impls/borrowed_locals.rs
index d5548266aa017..9ec68f5260c05 100644
--- a/compiler/rustc_mir_dataflow/src/impls/borrowed_locals.rs
+++ b/compiler/rustc_mir_dataflow/src/impls/borrowed_locals.rs
@@ -78,7 +78,8 @@ where
             // We ignore fake borrows as these get removed after analysis and shouldn't effect
             // the layout of generators.
             Rvalue::RawPtr(_, borrowed_place)
-            | Rvalue::Ref(_, BorrowKind::Mut { .. } | BorrowKind::Shared, borrowed_place) => {
+            | Rvalue::Ref(_, BorrowKind::Mut { .. } | BorrowKind::Shared, borrowed_place)
+            | Rvalue::Reborrow(_, _, borrowed_place) => {
                 if !borrowed_place.is_indirect() {
                     self.trans.gen_(borrowed_place.local);
                 }
diff --git a/compiler/rustc_mir_dataflow/src/move_paths/builder.rs b/compiler/rustc_mir_dataflow/src/move_paths/builder.rs
index 561836561b692..bd5dd850505fe 100644
--- a/compiler/rustc_mir_dataflow/src/move_paths/builder.rs
+++ b/compiler/rustc_mir_dataflow/src/move_paths/builder.rs
@@ -439,7 +439,10 @@ impl<'a, 'tcx, F: Fn(Ty<'tcx>) -> bool> MoveDataBuilder<'a, 'tcx, F> {
                 }
             }
             Rvalue::CopyForDeref(..) => unreachable!(),
-            Rvalue::Ref(..) | Rvalue::RawPtr(..) | Rvalue::Discriminant(..) => {}
+            Rvalue::Ref(..)
+            | Rvalue::Reborrow(..)
+            | Rvalue::RawPtr(..)
+            | Rvalue::Discriminant(..) => {}
         }
     }
 
diff --git a/compiler/rustc_mir_transform/src/add_subtyping_projections.rs b/compiler/rustc_mir_transform/src/add_subtyping_projections.rs
index a6a60fddf9097..fc31d502087fd 100644
--- a/compiler/rustc_mir_transform/src/add_subtyping_projections.rs
+++ b/compiler/rustc_mir_transform/src/add_subtyping_projections.rs
@@ -23,6 +23,9 @@ impl<'a, 'tcx> MutVisitor<'tcx> for SubTypeChecker<'a, 'tcx> {
         rvalue: &mut Rvalue<'tcx>,
         location: Location,
     ) {
+        if rvalue.is_generic_reborrow() {
+            return;
+        }
         // We don't need to do anything for deref temps as they are
         // not part of the source code, but used for desugaring purposes.
         if self.local_decls[place.local].is_deref_temp() {
diff --git a/compiler/rustc_mir_transform/src/dataflow_const_prop.rs b/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
index a2df3dcb85acf..ea1cbb1b5d60e 100644
--- a/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
+++ b/compiler/rustc_mir_transform/src/dataflow_const_prop.rs
@@ -472,7 +472,7 @@ impl<'a, 'tcx> ConstAnalysis<'a, 'tcx> {
             Rvalue::Discriminant(place) => state.get_discr(place.as_ref(), &self.map),
             Rvalue::Use(operand) => return self.handle_operand(operand, state),
             Rvalue::CopyForDeref(_) => bug!("`CopyForDeref` in runtime MIR"),
-            Rvalue::Ref(..) | Rvalue::RawPtr(..) => {
+            Rvalue::Ref(..) | Rvalue::Reborrow(..) | Rvalue::RawPtr(..) => {
                 // We don't track such places.
                 return ValueOrPlace::TOP;
             }
diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs
index 5324c39e9f222..6339941fb9963 100644
--- a/compiler/rustc_mir_transform/src/gvn.rs
+++ b/compiler/rustc_mir_transform/src/gvn.rs
@@ -1073,6 +1073,19 @@ 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(_, mutbl, place) => {
+                if mutbl == Mutability::Mut {
+                    let mut operand = Operand::Copy(place);
+                    let val = self.simplify_operand(&mut operand, location);
+                    *rvalue = Rvalue::Use(operand);
+                    return val;
+                } else {
+                    // FIXME(reborrow): CoerceShared should perform effectively a copy followed by a
+                    // transmute, or possibly something more complicated in the future. For now we
+                    // leave this unoptimised.
+                    return None;
+                }
+            }
             Rvalue::RawPtr(mutbl, ref mut place) => {
                 self.simplify_place_projection(place, location);
                 return self.new_pointer(*place, AddressKind::Address(mutbl));
diff --git a/compiler/rustc_mir_transform/src/known_panics_lint.rs b/compiler/rustc_mir_transform/src/known_panics_lint.rs
index 8beb00c5deffa..f9b4efd2e348a 100644
--- a/compiler/rustc_mir_transform/src/known_panics_lint.rs
+++ b/compiler/rustc_mir_transform/src/known_panics_lint.rs
@@ -421,8 +421,8 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
             }
 
             // Do not try creating references (#67862)
-            Rvalue::RawPtr(_, place) | Rvalue::Ref(_, _, place) => {
-                trace!("skipping RawPtr | Ref for {:?}", 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.
                 // If that happens, the pointed to value could be mutated via that reference.
@@ -553,7 +553,7 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
                 self.eval_operand(operand)?.into()
             }
 
-            CopyForDeref(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/lint.rs b/compiler/rustc_mir_transform/src/lint.rs
index e450e6754da13..e0b6b2a1104ea 100644
--- a/compiler/rustc_mir_transform/src/lint.rs
+++ b/compiler/rustc_mir_transform/src/lint.rs
@@ -96,6 +96,7 @@ impl<'a, 'tcx> Visitor<'tcx> for Lint<'a, 'tcx> {
                     | Rvalue::UnaryOp(..)
                     | Rvalue::BinaryOp(..)
                     | Rvalue::Ref(..)
+                    | Rvalue::Reborrow(..)
                     | Rvalue::RawPtr(..)
                     | Rvalue::Discriminant(..) => false,
                 };
diff --git a/compiler/rustc_mir_transform/src/promote_consts.rs b/compiler/rustc_mir_transform/src/promote_consts.rs
index a47b3ce64ed23..c08ef39fa53b5 100644
--- a/compiler/rustc_mir_transform/src/promote_consts.rs
+++ b/compiler/rustc_mir_transform/src/promote_consts.rs
@@ -575,6 +575,12 @@ impl<'tcx> Validator<'_, 'tcx> {
                 self.validate_ref(*kind, place)?;
             }
 
+            Rvalue::Reborrow(_, _, place) => {
+                // FIXME(reborrow): should probably have a place_simplified like above.
+                let op = &Operand::Copy(*place);
+                self.validate_operand(op)?
+            }
+
             Rvalue::Aggregate(_, operands) => {
                 for o in operands {
                     self.validate_operand(o)?;
diff --git a/compiler/rustc_mir_transform/src/validate.rs b/compiler/rustc_mir_transform/src/validate.rs
index 995a14c67e66c..9acb09156178e 100644
--- a/compiler/rustc_mir_transform/src/validate.rs
+++ b/compiler/rustc_mir_transform/src/validate.rs
@@ -1160,7 +1160,7 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                     );
                 }
             }
-            Rvalue::Ref(..) => {}
+            Rvalue::Ref(..) | Rvalue::Reborrow(..) => {}
             Rvalue::BinaryOp(op, vals) => {
                 use BinOp::*;
                 let a = vals.0.ty(&self.body.local_decls, self.tcx);
@@ -1471,7 +1471,12 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
             StatementKind::Assign(box (dest, rvalue)) => {
                 // LHS and RHS of the assignment must have the same type.
                 let left_ty = dest.ty(&self.body.local_decls, self.tcx).ty;
-                let right_ty = rvalue.ty(&self.body.local_decls, self.tcx);
+                let right_ty = if let Rvalue::Reborrow(target_ty, _, _) = rvalue {
+                    // CoerceShared changes the type from right_ty to target_ty.
+                    *target_ty
+                } else {
+                    rvalue.ty(&self.body.local_decls, self.tcx)
+                };
 
                 if !self.mir_assign_valid_types(right_ty, left_ty) {
                     self.fail(
@@ -1492,6 +1497,11 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                 {
                     self.fail(location, "assignment to a `DerefTemp` must use `CopyForDeref`")
                 }
+
+                if matches!(rvalue, Rvalue::Reborrow(..)) {
+                    // Reborrow/CoerceShared must not call into super_statement.
+                    return;
+                }
             }
             StatementKind::AscribeUserType(..) => {
                 if self.body.phase >= MirPhase::Runtime(RuntimePhase::Initial) {
diff --git a/compiler/rustc_public/src/mir/body.rs b/compiler/rustc_public/src/mir/body.rs
index 51757c5827221..05446a061c68c 100644
--- a/compiler/rustc_public/src/mir/body.rs
+++ b/compiler/rustc_public/src/mir/body.rs
@@ -589,6 +589,13 @@ pub enum Rvalue {
 
     /// Yields the operand unchanged
     Use(Operand),
+
+    /// Creates a bitwise copy of the source type, producing either a value of the same type (when
+    /// Mutability::Mut) or a different type with a guaranteed equal memory layout defined by the
+    /// CoerceShared trait. See [`Rvalue::Reborrow`] for a more detailed explanation.
+    ///
+    /// [`Rvalue::Reborrow`]: rustc_middle::mir::Rvalue::Reborrow
+    Reborrow(Ty, Mutability, Place),
 }
 
 impl Rvalue {
@@ -603,6 +610,7 @@ impl Rvalue {
                 let place_ty = place.ty(locals)?;
                 Ok(Ty::new_ref(reg.clone(), place_ty, bk.to_mutable_lossy()))
             }
+            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
index bf2655e9a789c..4b5137b286860 100644
--- a/compiler/rustc_public/src/mir/pretty.rs
+++ b/compiler/rustc_public/src/mir/pretty.rs
@@ -380,6 +380,13 @@ fn pretty_rvalue<W: Write>(writer: &mut W, rval: &Rvalue) -> io::Result<()> {
             };
             write!(writer, "{kind}{place:?}")
         }
+        Rvalue::Reborrow(target, mutability, place) => {
+            let kind = match mutability {
+                Mutability::Not => "Reborrow",
+                Mutability::Mut => "CoerceShared",
+            };
+            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
index e1d9cf31036e2..64294faa77490 100644
--- a/compiler/rustc_public/src/mir/visit.rs
+++ b/compiler/rustc_public/src/mir/visit.rs
@@ -273,6 +273,11 @@ macro_rules! make_mir_visitor {
                         let pcx = PlaceContext { is_mut: matches!(kind, BorrowKind::Mut { .. }) };
                         self.visit_place(place, pcx, location);
                     }
+                    Rvalue::Reborrow(target, mutability, place) => {
+                        self.visit_ty(target, location);
+                        let pcx = PlaceContext { is_mut: matches!(mutability, Mutability::Mut) };
+                        self.visit_place(place, pcx, location);
+                    }
                     Rvalue::Repeat(op, constant) => {
                         self.visit_operand(op, location);
                         self.visit_ty_const(constant, location);
diff --git a/compiler/rustc_public/src/unstable/convert/stable/mir.rs b/compiler/rustc_public/src/unstable/convert/stable/mir.rs
index 2bc23e2837048..d6e9f38b1c063 100644
--- a/compiler/rustc_public/src/unstable/convert/stable/mir.rs
+++ b/compiler/rustc_public/src/unstable/convert/stable/mir.rs
@@ -205,6 +205,11 @@ impl<'tcx> Stable<'tcx> for mir::Rvalue<'tcx> {
                 kind.stable(tables, cx),
                 place.stable(tables, cx),
             ),
+            Reborrow(target, kind, place) => crate::mir::Rvalue::Reborrow(
+                target.stable(tables, cx),
+                kind.stable(tables, cx),
+                place.stable(tables, cx),
+            ),
             ThreadLocalRef(def_id) => {
                 crate::mir::Rvalue::ThreadLocalRef(tables.crate_item(*def_id))
             }
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 702c3c54101c3..f0dc41584d5e9 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -286,6 +286,7 @@ symbols! {
         Rc,
         RcWeak,
         Ready,
+        Reborrow,
         RefCell,
         Reference,
         Relaxed,
@@ -624,6 +625,7 @@ symbols! {
         cmse_nonsecure_entry,
         coerce_pointee_validated,
         coerce_shared,
+        coerce_shared_target,
         coerce_unsized,
         coff,
         cold,
diff --git a/compiler/rustc_ty_utils/src/consts.rs b/compiler/rustc_ty_utils/src/consts.rs
index 49e0bdde37870..8ed32df656454 100644
--- a/compiler/rustc_ty_utils/src/consts.rs
+++ b/compiler/rustc_ty_utils/src/consts.rs
@@ -208,6 +208,9 @@ fn recurse_build<'tcx>(
         | ExprKind::ThreadLocalRef(_) => {
             error(GenericConstantTooComplexSub::OperationNotSupported(node.span))?
         }
+        ExprKind::Reborrow { .. } => {
+            todo!();
+        }
     })
 }
 
@@ -305,6 +308,9 @@ impl<'a, 'tcx> IsThirPolymorphic<'a, 'tcx> {
             | thir::ExprKind::InlineAsm(_)
             | thir::ExprKind::ThreadLocalRef(_)
             | thir::ExprKind::Yield { .. } => false,
+            thir::ExprKind::Reborrow { .. } => {
+                todo!();
+            }
         }
     }
     fn pat_is_poly(&mut self, pat: &thir::Pat<'tcx>) -> bool {
diff --git a/library/core/src/marker.rs b/library/core/src/marker.rs
index f56a4d7308e90..9e6b02f009837 100644
--- a/library/core/src/marker.rs
+++ b/library/core/src/marker.rs
@@ -1347,3 +1347,19 @@ pub macro CoercePointee($item:item) {
 pub trait CoercePointeeValidated {
     /* compiler built-in */
 }
+
+/// Allows value to be reborrowed as exclusive, creating a copy of the value
+/// that disables the source for reads and writes for the lifetime of the copy.
+#[lang = "reborrow"]
+#[unstable(feature = "reborrow", issue = "145612")]
+pub trait Reborrow {
+    /* compiler built-in */
+}
+
+/// Allows reborrowable value to be reborrowed as shared, creating a copy
+/// that disables the source for writes for the lifetime of the copy.
+#[lang = "coerce_shared"]
+#[unstable(feature = "reborrow", issue = "145612")]
+pub trait CoerceShared<Target: Copy>: Reborrow {
+    /* compiler built-in */
+}
diff --git a/library/core/src/ops/mod.rs b/library/core/src/ops/mod.rs
index ab1ad407ee282..87dd873fdb57d 100644
--- a/library/core/src/ops/mod.rs
+++ b/library/core/src/ops/mod.rs
@@ -149,7 +149,6 @@ mod function;
 mod index;
 mod index_range;
 mod range;
-mod reborrow;
 mod try_trait;
 mod unsize;
 
@@ -190,8 +189,6 @@ pub use self::range::{Bound, RangeBounds, RangeInclusive, RangeToInclusive};
 pub use self::range::{OneSidedRange, OneSidedRangeBound};
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use self::range::{Range, RangeFrom, RangeFull, RangeTo};
-#[unstable(feature = "reborrow", issue = "145612")]
-pub use self::reborrow::{CoerceShared, Reborrow};
 #[unstable(feature = "try_trait_v2_residual", issue = "91285")]
 pub use self::try_trait::Residual;
 #[unstable(feature = "try_trait_v2_yeet", issue = "96374")]
diff --git a/library/core/src/ops/reborrow.rs b/library/core/src/ops/reborrow.rs
deleted file mode 100644
index f83f4233a4de5..0000000000000
--- a/library/core/src/ops/reborrow.rs
+++ /dev/null
@@ -1,16 +0,0 @@
-/// Allows value to be reborrowed as exclusive, creating a copy of the value
-/// that disables the source for reads and writes for the lifetime of the copy.
-#[lang = "reborrow"]
-#[unstable(feature = "reborrow", issue = "145612")]
-pub trait Reborrow {
-    // Empty.
-}
-
-/// Allows reborrowable value to be reborrowed as shared, creating a copy
-/// that disables the source for writes for the lifetime of the copy.
-#[lang = "coerce_shared"]
-#[unstable(feature = "reborrow", issue = "145612")]
-pub trait CoerceShared: Reborrow {
-    /// The type of this value when reborrowed as shared.
-    type Target: Copy;
-}
diff --git a/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs b/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs
index 8f7a140e91a86..13ba8bef99730 100644
--- a/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs
+++ b/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs
@@ -129,7 +129,7 @@ fn check_rvalue<'tcx>(
 ) -> McfResult {
     match rvalue {
         Rvalue::ThreadLocalRef(_) => Err((span, "cannot access thread local storage in const fn".into())),
-        Rvalue::Discriminant(place) | Rvalue::Ref(_, _, place) | Rvalue::RawPtr(_, place) => {
+        Rvalue::Discriminant(place) | Rvalue::Ref(_, _, place) | Rvalue::Reborrow(_, _, place) | Rvalue::RawPtr(_, place) => {
             check_place(cx, *place, span, body, msrv)
         },
         Rvalue::CopyForDeref(place) => check_place(cx, *place, span, body, msrv),
diff --git a/tests/ui/feature-gates/feature-gate-reborrow-coerce-shared.rs b/tests/ui/feature-gates/feature-gate-reborrow-coerce-shared.rs
index c8ca453708912..48a14959d8d64 100644
--- a/tests/ui/feature-gates/feature-gate-reborrow-coerce-shared.rs
+++ b/tests/ui/feature-gates/feature-gate-reborrow-coerce-shared.rs
@@ -1,3 +1,3 @@
-use std::ops::CoerceShared; //~ ERROR  use of unstable library feature `reborrow`
+use std::marker::CoerceShared; //~ ERROR  use of unstable library feature `reborrow`
 
 fn main() {}
diff --git a/tests/ui/feature-gates/feature-gate-reborrow-coerce-shared.stderr b/tests/ui/feature-gates/feature-gate-reborrow-coerce-shared.stderr
index dbbbcdf2fd57d..c4c5e06778af3 100644
--- a/tests/ui/feature-gates/feature-gate-reborrow-coerce-shared.stderr
+++ b/tests/ui/feature-gates/feature-gate-reborrow-coerce-shared.stderr
@@ -1,8 +1,8 @@
 error[E0658]: use of unstable library feature `reborrow`
   --> $DIR/feature-gate-reborrow-coerce-shared.rs:1:5
    |
-LL | use std::ops::CoerceShared;
-   |     ^^^^^^^^^^^^^^^^^^^^^^
+LL | use std::marker::CoerceShared;
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: see issue #145612 <https://github.com/rust-lang/rust/issues/145612> for more information
    = help: add `#![feature(reborrow)]` to the crate attributes to enable
diff --git a/tests/ui/feature-gates/feature-gate-reborrow.rs b/tests/ui/feature-gates/feature-gate-reborrow.rs
index 96eecfb28a106..f016f6c6bfa59 100644
--- a/tests/ui/feature-gates/feature-gate-reborrow.rs
+++ b/tests/ui/feature-gates/feature-gate-reborrow.rs
@@ -1,3 +1,3 @@
-use std::ops::Reborrow; //~ ERROR  use of unstable library feature `reborrow`
+use std::marker::Reborrow; //~ ERROR  use of unstable library feature `reborrow`
 
 fn main() {}
diff --git a/tests/ui/feature-gates/feature-gate-reborrow.stderr b/tests/ui/feature-gates/feature-gate-reborrow.stderr
index 1224909f564bc..5e3033f3bf1fe 100644
--- a/tests/ui/feature-gates/feature-gate-reborrow.stderr
+++ b/tests/ui/feature-gates/feature-gate-reborrow.stderr
@@ -1,8 +1,8 @@
 error[E0658]: use of unstable library feature `reborrow`
   --> $DIR/feature-gate-reborrow.rs:1:5
    |
-LL | use std::ops::Reborrow;
-   |     ^^^^^^^^^^^^^^^^^^
+LL | use std::marker::Reborrow;
+   |     ^^^^^^^^^^^^^^^^^^^^^
    |
    = note: see issue #145612 <https://github.com/rust-lang/rust/issues/145612> for more information
    = help: add `#![feature(reborrow)]` to the crate attributes to enable
diff --git a/tests/ui/reborrow/custom_marker.rs b/tests/ui/reborrow/custom_marker.rs
new file mode 100644
index 0000000000000..80689d81d0cc1
--- /dev/null
+++ b/tests/ui/reborrow/custom_marker.rs
@@ -0,0 +1,17 @@
+//@ run-pass
+
+#![feature(reborrow)]
+use std::marker::{Reborrow, PhantomData};
+
+struct CustomMarker<'a>(PhantomData<&'a ()>);
+impl<'a> Reborrow for CustomMarker<'a> {}
+
+fn method<'a>(_a: CustomMarker<'a>) -> &'a () {
+    &()
+}
+
+fn main() {
+    let a = CustomMarker(PhantomData);
+    let _ = method(a);
+    let _ = method(a);
+}
diff --git a/tests/ui/reborrow/custom_marker_assign_deref.rs b/tests/ui/reborrow/custom_marker_assign_deref.rs
new file mode 100644
index 0000000000000..79ea2a35acdaf
--- /dev/null
+++ b/tests/ui/reborrow/custom_marker_assign_deref.rs
@@ -0,0 +1,26 @@
+//@ run-pass
+
+#![feature(reborrow)]
+use std::marker::{Reborrow, PhantomData};
+
+struct CustomMarker<'a>(PhantomData<&'a ()>);
+impl<'a> Reborrow for CustomMarker<'a> {}
+
+impl<'a> std::ops::Deref for CustomMarker<'a> {
+    type Target = CustomMarker<'a>;
+    fn deref(&self) -> &Self::Target {
+        self
+    }
+}
+
+impl<'a> std::ops::DerefMut for CustomMarker<'a> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self
+    }
+}
+
+fn main() {
+    let mut a = CustomMarker(PhantomData);
+
+    *a = CustomMarker(PhantomData);
+}
diff --git a/tests/ui/reborrow/custom_marker_coerce_shared.rs b/tests/ui/reborrow/custom_marker_coerce_shared.rs
new file mode 100644
index 0000000000000..17c7bac98d17a
--- /dev/null
+++ b/tests/ui/reborrow/custom_marker_coerce_shared.rs
@@ -0,0 +1,22 @@
+//@ run-pass
+
+#![feature(reborrow)]
+use std::marker::{CoerceShared, PhantomData, Reborrow};
+
+struct CustomMarker<'a>(PhantomData<&'a ()>);
+impl<'a> Reborrow for CustomMarker<'a> {}
+#[derive(Debug, Clone, Copy)]
+struct CustomMarkerRef<'a>(PhantomData<&'a ()>);
+impl<'a> CoerceShared<CustomMarkerRef<'a>> for CustomMarker<'a> {}
+
+
+fn method<'a>(_a: CustomMarkerRef<'a>) -> &'a () {
+    &()
+}
+
+fn main() {
+    let a = CustomMarker(PhantomData);
+    let b = method(a);
+    let c = method(a);
+    let _ = (b, c);
+}
diff --git a/tests/ui/reborrow/custom_marker_coerce_shared_copy.rs b/tests/ui/reborrow/custom_marker_coerce_shared_copy.rs
new file mode 100644
index 0000000000000..56bc1f896da0f
--- /dev/null
+++ b/tests/ui/reborrow/custom_marker_coerce_shared_copy.rs
@@ -0,0 +1,22 @@
+//@ run-pass
+
+#![feature(reborrow)]
+use std::marker::{CoerceShared, PhantomData, Reborrow};
+
+struct CustomMarker<'a>(PhantomData<&'a ()>);
+impl<'a> Reborrow for CustomMarker<'a> {}
+#[derive(Debug, Clone, Copy)]
+struct CustomMarkerRef<'a>(PhantomData<&'a ()>);
+impl<'a> CoerceShared<CustomMarkerRef<'a>> for CustomMarker<'a> {}
+
+
+fn method<'a>(_a: CustomMarkerRef<'a>) -> &'a () {
+    &()
+}
+
+fn main() {
+    let a = CustomMarker(PhantomData);
+    let b = method(a);
+    let c = method(a);
+    let _ = (&a, b, c);
+}
diff --git a/tests/ui/reborrow/custom_marker_coerce_shared_move.rs b/tests/ui/reborrow/custom_marker_coerce_shared_move.rs
new file mode 100644
index 0000000000000..532d13da258c8
--- /dev/null
+++ b/tests/ui/reborrow/custom_marker_coerce_shared_move.rs
@@ -0,0 +1,21 @@
+#![feature(reborrow)]
+use std::marker::{CoerceShared, PhantomData, Reborrow};
+
+struct CustomMarker<'a>(PhantomData<&'a ()>);
+impl<'a> Reborrow for CustomMarker<'a> {}
+#[derive(Clone, Copy)]
+struct CustomMarkerRef<'a>(PhantomData<&'a ()>);
+impl<'a> CoerceShared<CustomMarkerRef<'a>> for CustomMarker<'a> {}
+
+
+fn method<'a>(_a: CustomMarkerRef<'a>) -> &'a () {
+    &()
+}
+
+fn main() {
+    let a = CustomMarker(PhantomData);
+    let b = method(a);
+    let c = method(a);
+    let _ = (a, b, c);
+    //~^ ERROR: cannot move out of `a` because it is borrowed
+}
diff --git a/tests/ui/reborrow/custom_marker_coerce_shared_move.stderr b/tests/ui/reborrow/custom_marker_coerce_shared_move.stderr
new file mode 100644
index 0000000000000..90382af3ce30e
--- /dev/null
+++ b/tests/ui/reborrow/custom_marker_coerce_shared_move.stderr
@@ -0,0 +1,16 @@
+error[E0505]: cannot move out of `a` because it is borrowed
+  --> $DIR/custom_marker_coerce_shared_move.rs:19:14
+   |
+LL |     let a = CustomMarker(PhantomData);
+   |         - binding `a` declared here
+LL |     let b = method(a);
+   |                    - borrow of `a` occurs here
+LL |     let c = method(a);
+LL |     let _ = (a, b, c);
+   |              ^  - borrow later used here
+   |              |
+   |              move out of `a` occurs here
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0505`.
diff --git a/tests/ui/reborrow/custom_marker_deref.rs b/tests/ui/reborrow/custom_marker_deref.rs
new file mode 100644
index 0000000000000..74b9bac22ed0e
--- /dev/null
+++ b/tests/ui/reborrow/custom_marker_deref.rs
@@ -0,0 +1,17 @@
+//@ run-pass
+
+#![feature(reborrow)]
+use std::marker::{Reborrow, PhantomData};
+
+struct CustomMarker<'a>(PhantomData<&'a ()>);
+impl<'a> Reborrow for CustomMarker<'a> {}
+
+fn method<'a>(_a: CustomMarker<'a>) -> &'a () {
+    &()
+}
+
+fn main() {
+    let mut a = CustomMarker(PhantomData);
+    let b = &mut a;
+    let _ = method(*b);
+}
diff --git a/tests/ui/reborrow/custom_marker_mut_a_b.rs b/tests/ui/reborrow/custom_marker_mut_a_b.rs
new file mode 100644
index 0000000000000..3baf320b583b7
--- /dev/null
+++ b/tests/ui/reborrow/custom_marker_mut_a_b.rs
@@ -0,0 +1,17 @@
+#![feature(reborrow)]
+use std::marker::{Reborrow, PhantomData};
+
+struct CustomMarker<'a>(PhantomData<&'a ()>);
+impl<'a> Reborrow for CustomMarker<'a> {}
+
+fn method<'a>(_a: CustomMarker<'a>) -> &'a () {
+    &()
+}
+
+fn main() {
+    let a = CustomMarker(PhantomData);
+    let b = method(a);
+    let c = method(a);
+    //~^ ERROR: cannot borrow `a` as mutable more than once at a time
+    let _ = (b, c);
+}
diff --git a/tests/ui/reborrow/custom_marker_mut_a_b.stderr b/tests/ui/reborrow/custom_marker_mut_a_b.stderr
new file mode 100644
index 0000000000000..36e3bc2918032
--- /dev/null
+++ b/tests/ui/reborrow/custom_marker_mut_a_b.stderr
@@ -0,0 +1,14 @@
+error[E0499]: cannot borrow `a` as mutable more than once at a time
+  --> $DIR/custom_marker_mut_a_b.rs:14:20
+   |
+LL |     let b = method(a);
+   |                    - first mutable borrow occurs here
+LL |     let c = method(a);
+   |                    ^ second mutable borrow occurs here
+LL |
+LL |     let _ = (b, c);
+   |              - first borrow later used here
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0499`.
diff --git a/tests/ui/reborrow/custom_marker_mut_self.rs b/tests/ui/reborrow/custom_marker_mut_self.rs
new file mode 100644
index 0000000000000..a688f503517d0
--- /dev/null
+++ b/tests/ui/reborrow/custom_marker_mut_self.rs
@@ -0,0 +1,15 @@
+#![feature(reborrow)]
+use std::marker::{Reborrow, PhantomData};
+
+struct CustomMarker<'a>(PhantomData<&'a ()>);
+impl<'a> Reborrow for CustomMarker<'a> {}
+
+fn method<'a>(_a: CustomMarker<'a>) -> &'a () {
+    &()
+}
+
+fn main() {
+    let a = CustomMarker(PhantomData);
+    let b = method(a);
+    let _ = (a, b); //~ERROR cannot move out of `a` because it is borrowed
+}
diff --git a/tests/ui/reborrow/custom_marker_mut_self.stderr b/tests/ui/reborrow/custom_marker_mut_self.stderr
new file mode 100644
index 0000000000000..77262eed339db
--- /dev/null
+++ b/tests/ui/reborrow/custom_marker_mut_self.stderr
@@ -0,0 +1,15 @@
+error[E0505]: cannot move out of `a` because it is borrowed
+  --> $DIR/custom_marker_mut_self.rs:14:14
+   |
+LL |     let a = CustomMarker(PhantomData);
+   |         - binding `a` declared here
+LL |     let b = method(a);
+   |                    - borrow of `a` occurs here
+LL |     let _ = (a, b);
+   |              ^  - borrow later used here
+   |              |
+   |              move out of `a` occurs here
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0505`.
diff --git a/tests/ui/reborrow/custom_marker_mut_self_a.rs b/tests/ui/reborrow/custom_marker_mut_self_a.rs
new file mode 100644
index 0000000000000..f4cc8defb05e6
--- /dev/null
+++ b/tests/ui/reborrow/custom_marker_mut_self_a.rs
@@ -0,0 +1,18 @@
+#![feature(reborrow)]
+use std::marker::{Reborrow, PhantomData};
+
+struct CustomMarker<'a>(PhantomData<&'a ()>);
+impl<'a> Reborrow for CustomMarker<'a> {}
+
+fn method<'a>(_a: CustomMarker<'a>) -> &'a () {
+    &()
+}
+
+fn main() {
+    let a = CustomMarker(PhantomData);
+    let b = method(a);
+    let _ = method(a);
+    //~^ ERROR: cannot borrow `a` as mutable more than once at a time
+    let _ = (a, b);
+    //~^ ERROR: cannot move out of `a` because it is borrowed
+}
diff --git a/tests/ui/reborrow/custom_marker_mut_self_a.stderr b/tests/ui/reborrow/custom_marker_mut_self_a.stderr
new file mode 100644
index 0000000000000..4241b6ec15a20
--- /dev/null
+++ b/tests/ui/reborrow/custom_marker_mut_self_a.stderr
@@ -0,0 +1,28 @@
+error[E0499]: cannot borrow `a` as mutable more than once at a time
+  --> $DIR/custom_marker_mut_self_a.rs:14:20
+   |
+LL |     let b = method(a);
+   |                    - first mutable borrow occurs here
+LL |     let _ = method(a);
+   |                    ^ second mutable borrow occurs here
+LL |
+LL |     let _ = (a, b);
+   |                 - first borrow later used here
+
+error[E0505]: cannot move out of `a` because it is borrowed
+  --> $DIR/custom_marker_mut_self_a.rs:16:14
+   |
+LL |     let a = CustomMarker(PhantomData);
+   |         - binding `a` declared here
+LL |     let b = method(a);
+   |                    - borrow of `a` occurs here
+...
+LL |     let _ = (a, b);
+   |              ^  - borrow later used here
+   |              |
+   |              move out of `a` occurs here
+
+error: aborting due to 2 previous errors
+
+Some errors have detailed explanations: E0499, E0505.
+For more information about an error, try `rustc --explain E0499`.
diff --git a/tests/ui/reborrow/custom_marker_mut_self_b.rs b/tests/ui/reborrow/custom_marker_mut_self_b.rs
new file mode 100644
index 0000000000000..16356954908b0
--- /dev/null
+++ b/tests/ui/reborrow/custom_marker_mut_self_b.rs
@@ -0,0 +1,17 @@
+#![feature(reborrow)]
+use std::marker::{Reborrow, PhantomData};
+
+struct CustomMarker<'a>(PhantomData<&'a ()>);
+impl<'a> Reborrow for CustomMarker<'a> {}
+
+fn method<'a>(_a: CustomMarker<'a>) -> &'a () {
+    &()
+}
+
+fn main() {
+    let a = CustomMarker(PhantomData);
+    let _ = method(a);
+    let b = method(a);
+    let _ = (a, b);
+    //~^ ERROR: cannot move out of `a` because it is borrowed
+}
diff --git a/tests/ui/reborrow/custom_marker_mut_self_b.stderr b/tests/ui/reborrow/custom_marker_mut_self_b.stderr
new file mode 100644
index 0000000000000..adca4331f1bbf
--- /dev/null
+++ b/tests/ui/reborrow/custom_marker_mut_self_b.stderr
@@ -0,0 +1,16 @@
+error[E0505]: cannot move out of `a` because it is borrowed
+  --> $DIR/custom_marker_mut_self_b.rs:15:14
+   |
+LL |     let a = CustomMarker(PhantomData);
+   |         - binding `a` declared here
+LL |     let _ = method(a);
+LL |     let b = method(a);
+   |                    - borrow of `a` occurs here
+LL |     let _ = (a, b);
+   |              ^  - borrow later used here
+   |              |
+   |              move out of `a` occurs here
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0505`.
diff --git a/tests/ui/reborrow/custom_marker_two_lifetimes.rs b/tests/ui/reborrow/custom_marker_two_lifetimes.rs
new file mode 100644
index 0000000000000..d03282145054d
--- /dev/null
+++ b/tests/ui/reborrow/custom_marker_two_lifetimes.rs
@@ -0,0 +1,8 @@
+#![feature(reborrow)]
+use std::marker::{Reborrow, PhantomData};
+
+struct CustomMarker<'a, 'b>(PhantomData<&'a mut ()>, PhantomData<&'b ()>);
+impl<'a, 'b> Reborrow for CustomMarker<'a, 'b> {}
+//~^ ERROR: implementing `Reborrow` requires that a single lifetime parameter is passed between source and target
+
+fn main() {}
diff --git a/tests/ui/reborrow/custom_marker_two_lifetimes.stderr b/tests/ui/reborrow/custom_marker_two_lifetimes.stderr
new file mode 100644
index 0000000000000..ce5c4d09aeb79
--- /dev/null
+++ b/tests/ui/reborrow/custom_marker_two_lifetimes.stderr
@@ -0,0 +1,8 @@
+error: implementing `Reborrow` requires that a single lifetime parameter is passed between source and target
+  --> $DIR/custom_marker_two_lifetimes.rs:5:1
+   |
+LL | impl<'a, 'b> Reborrow for CustomMarker<'a, 'b> {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/reborrow/custom_mut.rs b/tests/ui/reborrow/custom_mut.rs
index 1e7c469323822..39b5ed4906102 100644
--- a/tests/ui/reborrow/custom_mut.rs
+++ b/tests/ui/reborrow/custom_mut.rs
@@ -1,13 +1,16 @@
+//@ run-pass
+
 #![feature(reborrow)]
-use std::ops::Reborrow;
+use std::marker::Reborrow;
 
+#[allow(unused)]
 struct CustomMut<'a, T>(&'a mut T);
 impl<'a, T> Reborrow for CustomMut<'a, T> {}
 
-fn method(a: CustomMut<'_, ()>) {}
+fn method(_: CustomMut<'_, ()>) {}
 
 fn main() {
     let a = CustomMut(&mut ());
     let _ = method(a);
-    let _ = method(a); //~ERROR use of moved value: `a`
+    let _ = method(a);
 }
diff --git a/tests/ui/reborrow/custom_mut.stderr b/tests/ui/reborrow/custom_mut.stderr
deleted file mode 100644
index 3b3f47b62d6fa..0000000000000
--- a/tests/ui/reborrow/custom_mut.stderr
+++ /dev/null
@@ -1,29 +0,0 @@
-error[E0382]: use of moved value: `a`
-  --> $DIR/custom_mut.rs:12:20
-   |
-LL |     let a = CustomMut(&mut ());
-   |         - move occurs because `a` has type `CustomMut<'_, ()>`, which does not implement the `Copy` trait
-LL |     let _ = method(a);
-   |                    - value moved here
-LL |     let _ = method(a);
-   |                    ^ value used here after move
-   |
-note: consider changing this parameter type in function `method` to borrow instead if owning the value isn't necessary
-  --> $DIR/custom_mut.rs:7:14
-   |
-LL | fn method(a: CustomMut<'_, ()>) {}
-   |    ------    ^^^^^^^^^^^^^^^^^ this parameter takes ownership of the value
-   |    |
-   |    in this function
-note: if `CustomMut<'_, ()>` implemented `Clone`, you could clone the value
-  --> $DIR/custom_mut.rs:4:1
-   |
-LL | struct CustomMut<'a, T>(&'a mut T);
-   | ^^^^^^^^^^^^^^^^^^^^^^^ consider implementing `Clone` for this type
-...
-LL |     let _ = method(a);
-   |                    - you could clone this value
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0382`.
diff --git a/tests/ui/reborrow/custom_mut_coerce_shared.rs b/tests/ui/reborrow/custom_mut_coerce_shared.rs
index e2d25835c093a..dcc02db5802bd 100644
--- a/tests/ui/reborrow/custom_mut_coerce_shared.rs
+++ b/tests/ui/reborrow/custom_mut_coerce_shared.rs
@@ -1,11 +1,12 @@
+//@ run-pass
+
 #![feature(reborrow)]
-use std::ops::{CoerceShared, Reborrow};
+use std::marker::{CoerceShared, Reborrow};
 
+#[allow(unused)]
 struct CustomMut<'a, T>(&'a mut T);
 impl<'a, T> Reborrow for CustomMut<'a, T> {}
-impl<'a, T> CoerceShared for CustomMut<'a, T> {
-    type Target = CustomRef<'a, T>;
-}
+impl<'a, T> CoerceShared<CustomRef<'a, T>> for CustomMut<'a, T> {}
 
 struct CustomRef<'a, T>(&'a T);
 
@@ -16,13 +17,9 @@ impl<'a, T> Clone for CustomRef<'a, T> {
 }
 impl<'a, T> Copy for CustomRef<'a, T> {}
 
-fn method(a: CustomRef<'_, ()>) {}  //~NOTE function defined here
+fn method(_a: CustomRef<'_, ()>) {}
 
 fn main() {
     let a = CustomMut(&mut ());
     method(a);
-    //~^ ERROR mismatched types
-    //~| NOTE expected `CustomRef<'_, ()>`, found `CustomMut<'_, ()>`
-    //~| NOTE arguments to this function are incorrect
-    //~| NOTE expected struct `CustomRef<'_, ()>`
 }
diff --git a/tests/ui/reborrow/custom_mut_coerce_shared.stderr b/tests/ui/reborrow/custom_mut_coerce_shared.stderr
deleted file mode 100644
index 508651badc0a4..0000000000000
--- a/tests/ui/reborrow/custom_mut_coerce_shared.stderr
+++ /dev/null
@@ -1,19 +0,0 @@
-error[E0308]: mismatched types
-  --> $DIR/custom_mut_coerce_shared.rs:23:12
-   |
-LL |     method(a);
-   |     ------ ^ expected `CustomRef<'_, ()>`, found `CustomMut<'_, ()>`
-   |     |
-   |     arguments to this function are incorrect
-   |
-   = note: expected struct `CustomRef<'_, ()>`
-              found struct `CustomMut<'_, ()>`
-note: function defined here
-  --> $DIR/custom_mut_coerce_shared.rs:19:4
-   |
-LL | fn method(a: CustomRef<'_, ()>) {}
-   |    ^^^^^^ --------------------
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0308`.