Auto merge of rust-lang#145513 - beepster4096:erasedereftemps, r=saethlin,cjgillot

Validate CopyForDeref and DerefTemps better and remove them from runtime MIR (split from my WIP rust-lang#145344) This PR: - Removes `Rvalue::CopyForDeref` and `LocalInfo::DerefTemp` from runtime MIR - Using a new mir pass `EraseDerefTemps` - `CopyForDeref(x)` is turned into `Use(Copy(x))` - `DerefTemp` is turned into `Boring` - Not sure if this part is actually necessary, it made more sense in rust-lang#145344 with `DerefTemp` storing actual data that I wanted to keep from having to be kept in sync with the rest of the body in runtime MIR - Checks in validation that `CopyForDeref` and `DerefTemp` are only used together - Removes special handling for `CopyForDeref` from many places - Removes `CopyForDeref` from `custom_mir` reverting rust-lang#111587 - In runtime MIR simple copies can be used instead - In post cleanup analysis MIR it was already wrong to use due to the lack of support for creating `DerefTemp` locals - Possibly this should be its own PR? - Adds an argument to `deref_finder` to avoid creating new `DerefTemp`s and `CopyForDeref` in runtime MIR. - Ideally we would just avoid making intermediate derefs instead of fixing it at the end of a pass / during shim building - Removes some usages of `deref_finder` that I found out don't actually do anything r? oli-obk

Author: bors

compiler/rustc_borrowck/src/lib.rs

@@ -1538,24 +1538,6 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
  self.consume_operand(location, (operand, span), state)
  }
 
- &Rvalue::CopyForDeref(place) => {
- self.access_place(
- location,
- (place, span),
- (Deep, Read(ReadKind::Copy)),
- LocalMutationIsAllowed::No,
- state,
- );
-
- // Finally, check if path was already moved.
- self.check_if_path_or_subpath_is_moved(
- location,
- InitializationRequiringAction::Use,
- (place.as_ref(), span),
- state,
- );
- }
-
  &Rvalue::Discriminant(place) => {
  let af = match *rvalue {
  Rvalue::Discriminant(..) => None,
@@ -1617,6 +1599,8 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
  Rvalue::WrapUnsafeBinder(op, _) => {
  self.consume_operand(location, (op, span), state);
  }
+
+ Rvalue::CopyForDeref(_) => bug!("`CopyForDeref` in borrowck"),
  }
  }
 

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

@@ -300,11 +300,6 @@ impl<'a, 'tcx> LoanInvalidationsGenerator<'a, 'tcx> {
  | Rvalue::Cast(_ /*cast_kind*/, operand, _ /*ty*/)
  | Rvalue::ShallowInitBox(operand, _ /*ty*/) => self.consume_operand(location, operand),
 
- &Rvalue::CopyForDeref(place) => {
- let op = &Operand::Copy(place);
- self.consume_operand(location, op);
- }
-
  &Rvalue::Discriminant(place) => {
  self.access_place(
  location,
@@ -330,6 +325,8 @@ impl<'a, 'tcx> LoanInvalidationsGenerator<'a, 'tcx> {
  Rvalue::WrapUnsafeBinder(op, _) => {
  self.consume_operand(location, op);
  }
+
+ Rvalue::CopyForDeref(_) => bug!("`CopyForDeref` in borrowck"),
  }
  }
 

compiler/rustc_codegen_cranelift/src/base.rs

@@ -600,11 +600,6 @@ fn codegen_stmt<'tcx>(fx: &mut FunctionCx<'_, '_, 'tcx>, cur_block: Block, stmt:
  let val = codegen_operand(fx, operand);
  lval.write_cvalue(fx, val);
  }
- Rvalue::CopyForDeref(place) => {
- let cplace = codegen_place(fx, place);
- let val = cplace.to_cvalue(fx);
- lval.write_cvalue(fx, val)
- }
  Rvalue::Ref(_, _, place) | Rvalue::RawPtr(_, place) => {
  let place = codegen_place(fx, place);
  let ref_ = place.place_ref(fx, lval.layout());
@@ -928,6 +923,7 @@ fn codegen_stmt<'tcx>(fx: &mut FunctionCx<'_, '_, 'tcx>, cur_block: Block, stmt:
  let operand = codegen_operand(fx, operand);
  lval.write_cvalue_transmute(fx, operand);
  }
+ Rvalue::CopyForDeref(_) => bug!("`CopyForDeref` in codegen"),
  }
  }
  StatementKind::StorageLive(_)

compiler/rustc_codegen_ssa/src/mir/rvalue.rs

@@ -504,9 +504,6 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
  self.codegen_place_to_pointer(bx, place, mk_ref)
  }
 
- mir::Rvalue::CopyForDeref(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())
@@ -742,6 +739,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
  let layout = bx.cx().layout_of(binder_ty);
  OperandRef { val: operand.val, layout }
  }
+ mir::Rvalue::CopyForDeref(_) => bug!("`CopyForDeref` in codegen"),
  }
  }
 

compiler/rustc_const_eval/src/check_consts/qualifs.rs

@@ -234,7 +234,7 @@ where
 
  Rvalue::Discriminant(place) => in_place::<Q, _>(cx, in_local, place.as_ref()),
 
- Rvalue::CopyForDeref(place) => in_place::<Q, _>(cx, in_local, place.as_ref()),
+ Rvalue::CopyForDeref(_) => bug!("`CopyForDeref` in runtime MIR"),
 
  Rvalue::Use(operand)
  | Rvalue::Repeat(operand, _)

compiler/rustc_const_eval/src/interpret/step.rs

@@ -183,10 +183,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
  self.copy_op(&op, &dest)?;
  }
 
- CopyForDeref(place) => {
- let op = self.eval_place_to_op(place, Some(dest.layout))?;
- self.copy_op(&op, &dest)?;
- }
+ CopyForDeref(_) => bug!("`CopyForDeref` in runtime MIR"),
 
  BinaryOp(bin_op, box (ref left, ref right)) => {
  let layout = util::binop_left_homogeneous(bin_op).then_some(dest.layout);

compiler/rustc_middle/src/mir/mod.rs

@@ -1065,7 +1065,11 @@ pub enum LocalInfo<'tcx> {
  /// A temporary created during evaluating `if` predicate, possibly for pattern matching for `let`s,
  /// and subject to Edition 2024 temporary lifetime rules
  IfThenRescopeTemp { if_then: HirId },
- /// A temporary created during the pass `Derefer` to avoid it's retagging
+ /// A temporary created during the pass `Derefer` treated as a transparent alias
+ /// for the place its copied from by analysis passes such as `AddRetag` and `ElaborateDrops`.
+ ///
+ /// It may only be written to by a `CopyForDeref` and otherwise only accessed through a deref.
+ /// In runtime MIR, it is replaced with a normal `Boring` local.
  DerefTemp,
  /// A temporary created for borrow checking.
  FakeBorrow,

compiler/rustc_middle/src/mir/syntax.rs

@@ -130,7 +130,9 @@ pub enum RuntimePhase {
  /// * [`TerminatorKind::Yield`]
  /// * [`TerminatorKind::CoroutineDrop`]
  /// * [`Rvalue::Aggregate`] for any `AggregateKind` except `Array`
+ /// * [`Rvalue::CopyForDeref`]
  /// * [`PlaceElem::OpaqueCast`]
+ /// * [`LocalInfo::DerefTemp`](super::LocalInfo::DerefTemp)
  ///
  /// And the following variants are allowed:
  /// * [`StatementKind::Retag`]
@@ -1454,11 +1456,13 @@ pub enum Rvalue<'tcx> {
  /// A CopyForDeref is equivalent to a read from a place at the
  /// codegen level, but is treated specially by drop elaboration. When such a read happens, it
  /// is guaranteed (via nature of the mir_opt `Derefer` in rustc_mir_transform/src/deref_separator)
- /// that the only use of the returned value is a deref operation, immediately
- /// followed by one or more projections. Drop elaboration treats this rvalue as if the
+ /// that the returned value is written into a `DerefTemp` local and that its only use is a deref operation,
+ /// immediately followed by one or more projections. Drop elaboration treats this rvalue as if the
  /// read never happened and just projects further. This allows simplifying various MIR
  /// optimizations and codegen backends that previously had to handle deref operations anywhere
  /// in a place.
+ ///
+ /// Disallowed in runtime MIR and is replaced by normal copies.
  CopyForDeref(Place<'tcx>),
 
  /// Wraps a value in an unsafe binder.

compiler/rustc_mir_build/src/builder/custom/parse/instruction.rs

@@ -250,7 +250,6 @@ impl<'a, 'tcx> ParseCtxt<'a, 'tcx> {
  Ok(Rvalue::BinaryOp(BinOp::Offset, Box::new((ptr, offset))))
  },
  @call(mir_ptr_metadata, args) => Ok(Rvalue::UnaryOp(UnOp::PtrMetadata, self.parse_operand(args[0])?)),
- @call(mir_copy_for_deref, args) => Ok(Rvalue::CopyForDeref(self.parse_place(args[0])?)),
  ExprKind::Borrow { borrow_kind, arg } => Ok(
  Rvalue::Ref(self.tcx.lifetimes.re_erased, *borrow_kind, self.parse_place(*arg)?)
  ),

compiler/rustc_mir_transform/src/copy_prop.rs

@@ -74,9 +74,7 @@ fn fully_moved_locals(ssa: &SsaLocals, body: &Body<'_>) -> DenseBitSet<Local> {
  let mut fully_moved = DenseBitSet::new_filled(body.local_decls.len());
 
  for (_, rvalue, _) in ssa.assignments(body) {
- let (Rvalue::Use(Operand::Copy(place) | Operand::Move(place))
- | Rvalue::CopyForDeref(place)) = rvalue
- else {
+ let Rvalue::Use(Operand::Copy(place) | Operand::Move(place)) = rvalue else {
  continue;
  };
 
@@ -85,7 +83,7 @@ fn fully_moved_locals(ssa: &SsaLocals, body: &Body<'_>) -> DenseBitSet<Local> {
  continue;
  }
 
- if let Rvalue::Use(Operand::Copy(_)) | Rvalue::CopyForDeref(_) = rvalue {
+ if let Rvalue::Use(Operand::Copy(_)) = rvalue {
  fully_moved.remove(rhs);
  }
  }
@@ -146,8 +144,7 @@ impl<'tcx> MutVisitor<'tcx> for Replacer<'_, 'tcx> {
 
  // Do not leave tautological assignments around.
  if let StatementKind::Assign(box (lhs, ref rhs)) = stmt.kind
- && let Rvalue::Use(Operand::Copy(rhs) | Operand::Move(rhs)) | Rvalue::CopyForDeref(rhs) =
- *rhs
+ && let Rvalue::Use(Operand::Copy(rhs) | Operand::Move(rhs)) = *rhs
  && lhs == rhs
  {
  stmt.make_nop(true);