fix rebase error - break feature with refactor to avoid visit_assign

Author: aapoalas

compiler/rustc_borrowck/src/borrow_set.rs

@@ -302,7 +302,7 @@ impl<'a, 'tcx> Visitor<'tcx> for GatherBorrows<'a, 'tcx> {
             };
 
             self.local_map.entry(borrowed_place.local).or_default().insert(idx);
-        } else if let &mir::Rvalue::Reborrow(mutability, borrowed_place, _target) = rvalue {
+        } 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!()

compiler/rustc_borrowck/src/dataflow.rs

@@ -549,7 +549,7 @@ impl<'tcx> rustc_mir_dataflow::Analysis<'tcx> for Borrows<'_, 'tcx> {
     ) {
         match &stmt.kind {
             mir::StatementKind::Assign(box (lhs, rhs)) => {
-                if let mir::Rvalue::Ref(_, _, place) | mir::Rvalue::Reborrow(_, place, _) = rhs {
+                if let mir::Rvalue::Ref(_, _, place) | mir::Rvalue::Reborrow(_, _, place) = rhs {
                     if place.ignore_borrow(
                         self.tcx,
                         self.body,

compiler/rustc_borrowck/src/lib.rs

@@ -1509,7 +1509,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
                 );
             }
 
-            &Rvalue::Reborrow(mutability, place, _target) => {
+            &Rvalue::Reborrow(_target, mutability, place) => {
                 let access_kind = (
                     Deep,
                     if mutability == Mutability::Mut {

compiler/rustc_borrowck/src/polonius/legacy/loan_invalidations.rs

@@ -275,7 +275,7 @@ impl<'a, 'tcx> LoanInvalidationsGenerator<'a, 'tcx> {
                 self.access_place(location, place, access_kind, LocalMutationIsAllowed::No);
             }
 
-            &Rvalue::Reborrow(mutability, place, _target) => {
+            &Rvalue::Reborrow(_target, mutability, place) => {
                 let access_kind = (
                     Deep,
                     if mutability == Mutability::Mut {

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -550,16 +550,6 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
 }
 
 impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
-    fn visit_assign(&mut self, place: &Place<'tcx>, rvalue: &Rvalue<'tcx>, location: Location) {
-        if let Rvalue::Reborrow(mutability, rvalue, _) = rvalue {
-            // check rvalue is Reborrow
-            self.add_generic_reborrow_constraint(*mutability, location, place, rvalue);
-        } else {
-            // rest of the cases
-            self.super_assign(place, rvalue, location);
-        }
-    }
-
     fn visit_span(&mut self, span: Span) {
         if !span.is_dummy() {
             debug!(?span);
@@ -637,10 +627,7 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                 debug!(?rv_ty);
                 let rv_ty = self.normalize(rv_ty, location);
                 debug!("normalized rv_ty: {:?}", rv_ty);
-                if let Rvalue::Reborrow(mutability, rvalue, _) = rv {
-                    // check rvalue is Reborrow
-                    self.add_generic_reborrow_constraint(*mutability, location, place, rvalue);
-                } else if let Err(terr) =
+                if let Err(terr) =
                     self.sub_types(rv_ty, place_ty, location.to_locations(), category)
                 {
                     span_mirbug!(
@@ -1594,10 +1581,15 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                 self.add_reborrow_constraint(location, *region, borrowed_place);
             }
 
-            Rvalue::Reborrow(..) => {
+            Rvalue::Reborrow(target, mutability, borrowed_place) => {
                 // Reborrow needs to produce a relation between the source and destination fields,
                 // which means that we have had to already handle this in visit_assign.
-                unreachable!()
+                self.add_generic_reborrow_constraint(
+                    *mutability,
+                    location,
+                    borrowed_place,
+                    *target,
+                );
             }
 
             Rvalue::BinaryOp(
@@ -2445,8 +2437,8 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
         &mut self,
         mutability: Mutability,
         location: Location,
-        dest: &Place<'tcx>,
         borrowed_place: &Place<'tcx>,
+        dest_ty: Ty<'tcx>,
     ) {
         // These constraints are only meaningful during borrowck:
         let Self { borrow_set, location_table, polonius_facts, constraints, infcx, body, .. } =
@@ -2459,7 +2451,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
 
         debug!(
             "add_generic_reborrow_constraint({:?}, {:?}, {:?}, {:?})",
-            mutability, location, dest, borrowed_place
+            mutability, location, borrowed_place, dest_ty
         );
 
         let tcx = infcx.tcx;
@@ -2473,19 +2465,19 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
             ConstraintCategory::Boring
         };
 
-        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!() };
-        constraints.liveness_constraints.add_location(reborrow_region.as_var(), location);
+
+        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 = reborrow_region.as_var();
+                let region_vid = dest_region.as_var();
                 polonius_facts.loan_issued_at.push((
                     region_vid.into(),
                     borrow_index,
@@ -2501,7 +2493,6 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
             // `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(dest_adt, dest_args) = dest_ty.kind() else { unreachable!() };
             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() {

compiler/rustc_codegen_cranelift/src/base.rs

@@ -629,7 +629,7 @@ 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) => {
+                Rvalue::Reborrow(_, _, place) => {
                     let cplace = codegen_place(fx, place);
                     let val = cplace.to_cvalue(fx);
                     lval.write_cvalue(fx, val)

compiler/rustc_codegen_ssa/src/mir/rvalue.rs

@@ -514,7 +514,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             // Generic shared reborrowing is not (necessarily) a simple memcpy, but currently the
             // coherence check places such restrictions on the CoerceShared trait as to guarantee
             // that it is.
-            mir::Rvalue::Reborrow(_, place, _) => {
+            mir::Rvalue::Reborrow(_, _, place) => {
                 self.codegen_operand(bx, &mir::Operand::Copy(place))
             }
 

compiler/rustc_const_eval/src/check_consts/qualifs.rs

@@ -255,7 +255,7 @@ where
             in_place::<Q, _>(cx, in_local, place.as_ref())
         }
 
-        Rvalue::Reborrow(_, place, _) => in_place::<Q, _>(cx, in_local, place.as_ref()),
+        Rvalue::Reborrow(_, _, place) => in_place::<Q, _>(cx, in_local, place.as_ref()),
 
         Rvalue::WrapUnsafeBinder(op, _) => in_operand::<Q, _>(cx, in_local, op),
 

compiler/rustc_const_eval/src/check_consts/resolver.rs

@@ -191,7 +191,7 @@ where
                 }
             }
 
-            mir::Rvalue::Reborrow(mutability, borrowed_place, _target) => {
+            mir::Rvalue::Reborrow(_target, mutability, borrowed_place) => {
                 if !borrowed_place.is_indirect() && mutability.is_mut() {
                     let place_ty = borrowed_place.ty(self.ccx.body, self.ccx.tcx).ty;
                     if Q::in_any_value_of_ty(self.ccx, place_ty) {

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() {
@@ -269,11 +274,6 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
                 let op = self.eval_operand(op, None)?;
                 self.copy_op_allow_transmute(&op, &dest)?;
             }
-
-            Reborrow(_, place, _) => {
-                let op = self.eval_place_to_op(place, Some(dest.layout))?;
-                self.copy_op(&op, &dest)?;
-            }
         }
 
         trace!("{:?}", self.dump_place(&dest));