Fix lifetime of reborrow by Ding Xiang Fei

Author: aapoalas

compiler/rustc_borrowck/src/borrow_set.rs

@@ -304,10 +304,12 @@ impl<'a, 'tcx> Visitor<'tcx> for GatherBorrows<'a, 'tcx> {
             self.local_map.entry(borrowed_place.local).or_default().insert(idx);
         } else if let &mir::Rvalue::Reborrow(mutability, borrowed_place) = rvalue {
             let borrowed_place_ty = borrowed_place.ty(self.body, self.tcx).ty;
-            let &ty::Adt(reborrowed_adt, reborrowed_args) = borrowed_place_ty.kind() else {
+            let &ty::Adt(reborrowed_adt, _reborrowed_args) = borrowed_place_ty.kind() else {
                 unreachable!()
             };
-            let &ty::Adt(target_adt, _) = assigned_place.ty(self.body, self.tcx).ty.kind() else {
+            let &ty::Adt(target_adt, assigned_args) =
+                assigned_place.ty(self.body, self.tcx).ty.kind()
+            else {
                 unreachable!()
             };
             let borrow = if mutability == Mutability::Mut {
@@ -318,7 +320,7 @@ impl<'a, 'tcx> Visitor<'tcx> for GatherBorrows<'a, 'tcx> {
                     )
                 }
                 let Some(ty::GenericArgKind::Lifetime(region)) =
-                    reborrowed_args.get(0).map(|r| r.kind())
+                    assigned_args.get(0).map(|r| r.kind())
                 else {
                     bug!(
                         "hir-typeck passed but {} does not have a lifetime argument",
@@ -343,7 +345,7 @@ impl<'a, 'tcx> Visitor<'tcx> for GatherBorrows<'a, 'tcx> {
                     )
                 }
                 let Some(ty::GenericArgKind::Lifetime(region)) =
-                    reborrowed_args.get(0).map(|r| r.kind())
+                    assigned_args.get(0).map(|r| r.kind())
                 else {
                     bug!(
                         "hir-typeck passed but {} does not have a lifetime argument",

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -2503,6 +2503,10 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
 
         let dest_ty = dest.ty(self.body, tcx).ty;
         let borrowed_ty = borrowed_place.ty(self.body, tcx).ty;
+        let ty::Adt(_, args) = dest_ty.kind() else { bug!() };
+        let [arg, ..] = ***args else { bug!() };
+        let ty::GenericArgKind::Lifetime(reborrow_region) = arg.kind() else { bug!() };
+        self.constraints.liveness_constraints.add_location(reborrow_region.as_var(), location);
 
         if mutability.is_not() {
             // FIXME: for shared reborrow we need to relate the types manually,
@@ -2520,14 +2524,20 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                 };
                 let dest_ty = dest_field.ty(tcx, dest_args);
                 let borrowed_ty = borrowed_field.ty(tcx, borrowed_args);
-                self.relate_types(
-                    borrowed_ty,
-                    ty::Variance::Covariant,
-                    dest_ty,
-                    location.to_locations(),
-                    category,
-                )
-                .unwrap();
+                if borrowed_ty.ref_mutability() == Some(Mutability::Mut)
+                    && dest_ty.ref_mutability() == Some(Mutability::Not)
+                {
+                    // self.add_reborrow_constraint(location, borrow_region, borrowed_place);
+                } else {
+                    self.relate_types(
+                        borrowed_ty,
+                        ty::Variance::Covariant,
+                        dest_ty,
+                        location.to_locations(),
+                        category,
+                    )
+                    .unwrap();
+                }
             }
         } else {
             // Exclusive reborrow

compiler/rustc_hir_analysis/src/coherence/builtin.rs

@@ -534,6 +534,10 @@ fn assert_field_type_is_reborrow<'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 =
@@ -667,6 +671,20 @@ pub(crate) fn coerce_shared_info<'tcx>(
         //
         // 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(CoerceSharedInfo {});
+        }
         if infcx
             .eq_structurally_relating_aliases(param_env, source, target, source_field_span)
             .is_err()