Auto merge of rust-lang#106090 - WaffleLapkin:dereffffffffff, r=Nilst…

…rieb

Remove some `ref` patterns from the compiler

Previous PR: rust-lang#105368

r? `@Nilstrieb`

compiler/rustc_const_eval/src/const_eval/error.rs

@@ -36,16 +36,16 @@ impl<'tcx> Into<InterpErrorInfo<'tcx>> for ConstEvalErrKind {
 impl fmt::Display for ConstEvalErrKind {
  fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  use self::ConstEvalErrKind::*;
- match *self {
+ match self {
  ConstAccessesStatic => write!(f, "constant accesses static"),
  ModifiedGlobal => {
  write!(f, "modifying a static's initial value from another static's initializer")
  }
- AssertFailure(ref msg) => write!(f, "{:?}", msg),
+ AssertFailure(msg) => write!(f, "{:?}", msg),
  Panic { msg, line, col, file } => {
  write!(f, "the evaluated program panicked at '{}', {}:{}:{}", msg, file, line, col)
  }
- Abort(ref msg) => write!(f, "{}", msg),
+ Abort(msg) => write!(f, "{}", msg),
  }
  }
 }

compiler/rustc_const_eval/src/const_eval/machine.rs

@@ -533,7 +533,7 @@ impl<'mir, 'tcx> interpret::Machine<'mir, 'tcx> for CompileTimeInterpreter<'mir,
  let eval_to_int =
  |op| ecx.read_immediate(&ecx.eval_operand(op, None)?).map(|x| x.to_const_int());
  let err = match msg {
- BoundsCheck { ref len, ref index } => {
+ BoundsCheck { len, index } => {
  let len = eval_to_int(len)?;
  let index = eval_to_int(index)?;
  BoundsCheck { len, index }

compiler/rustc_const_eval/src/interpret/cast.rs

@@ -347,7 +347,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
  let new_vptr = self.get_vtable_ptr(ty, data_b.principal())?;
  self.write_immediate(Immediate::new_dyn_trait(old_data, new_vptr, self), dest)
  }
- (_, &ty::Dynamic(ref data, _, ty::Dyn)) => {
+ (_, &ty::Dynamic(data, _, ty::Dyn)) => {
  // Initial cast from sized to dyn trait
  let vtable = self.get_vtable_ptr(src_pointee_ty, data.principal())?;
  let ptr = self.read_scalar(src)?;

compiler/rustc_const_eval/src/interpret/intrinsics.rs

@@ -79,9 +79,7 @@ pub(crate) fn eval_nullary_intrinsic<'tcx>(
  }
  sym::variant_count => match tp_ty.kind() {
  // Correctly handles non-monomorphic calls, so there is no need for ensure_monomorphic_enough.
- ty::Adt(ref adt, _) => {
- ConstValue::from_machine_usize(adt.variants().len() as u64, &tcx)
- }
+ ty::Adt(adt, _) => ConstValue::from_machine_usize(adt.variants().len() as u64, &tcx),
  ty::Alias(..) | ty::Param(_) | ty::Placeholder(_) | ty::Infer(_) => {
  throw_inval!(TooGeneric)
  }

compiler/rustc_const_eval/src/interpret/memory.rs

@@ -863,7 +863,7 @@ impl<'a, 'mir, 'tcx, M: Machine<'mir, 'tcx>> std::fmt::Debug for DumpAllocs<'a,
 
  write!(fmt, "{id:?}")?;
  match self.ecx.memory.alloc_map.get(id) {
- Some(&(kind, ref alloc)) => {
+ Some((kind, alloc)) => {
  // normal alloc
  write!(fmt, " ({}, ", kind)?;
  write_allocation_track_relocs(

compiler/rustc_const_eval/src/interpret/operand.rs

@@ -533,11 +533,11 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
  layout: Option<TyAndLayout<'tcx>>,
  ) -> InterpResult<'tcx, OpTy<'tcx, M::Provenance>> {
  use rustc_middle::mir::Operand::*;
- let op = match *mir_op {
+ let op = match mir_op {
  // FIXME: do some more logic on `move` to invalidate the old location
- Copy(place) | Move(place) => self.eval_place_to_op(place, layout)?,
+ &Copy(place) | &Move(place) => self.eval_place_to_op(place, layout)?,
 
- Constant(ref constant) => {
+ Constant(constant) => {
  let c =
  self.subst_from_current_frame_and_normalize_erasing_regions(constant.literal)?;
 

compiler/rustc_const_eval/src/interpret/step.rs

@@ -111,7 +111,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
  M::retag_place_contents(self, *kind, &dest)?;
  }
 
- Intrinsic(box ref intrinsic) => self.emulate_nondiverging_intrinsic(intrinsic)?,
+ Intrinsic(box intrinsic) => self.emulate_nondiverging_intrinsic(intrinsic)?,
 
  // Statements we do not track.
  AscribeUserType(..) => {}
@@ -163,8 +163,8 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
  self.copy_op(&op, &dest, /*allow_transmute*/ false)?;
  }
 
- CopyForDeref(ref place) => {
- let op = self.eval_place_to_op(*place, Some(dest.layout))?;
+ CopyForDeref(place) => {
+ let op = self.eval_place_to_op(place, Some(dest.layout))?;
  self.copy_op(&op, &dest, /* allow_transmute*/ false)?;
  }
 

compiler/rustc_const_eval/src/interpret/validity.rs

@@ -419,7 +419,7 @@ impl<'rt, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValidityVisitor<'rt, 'mir, '
  )
  }
  // Recursive checking
- if let Some(ref mut ref_tracking) = self.ref_tracking {
+ if let Some(ref_tracking) = self.ref_tracking.as_deref_mut() {
  // Proceed recursively even for ZST, no reason to skip them!
  // `!` is a ZST and we want to validate it.
  if let Ok((alloc_id, _offset, _prov)) = self.ecx.ptr_try_get_alloc_id(place.ptr) {

compiler/rustc_const_eval/src/interpret/visitor.rs

@@ -481,12 +481,12 @@ macro_rules! make_value_visitor {
  };
 
  // Visit the fields of this value.
- match v.layout().fields {
+ match &v.layout().fields {
  FieldsShape::Primitive => {}
- FieldsShape::Union(fields) => {
+ &FieldsShape::Union(fields) => {
  self.visit_union(v, fields)?;
  }
- FieldsShape::Arbitrary { ref offsets, .. } => {
+ FieldsShape::Arbitrary { offsets, .. } => {
  // FIXME: We collect in a vec because otherwise there are lifetime
  // errors: Projecting to a field needs access to `ecx`.
  let fields: Vec<InterpResult<'tcx, Self::V>> =

compiler/rustc_const_eval/src/transform/check_consts/check.rs

@@ -442,7 +442,7 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
 
  self.super_rvalue(rvalue, location);
 
- match *rvalue {
+ match rvalue {
  Rvalue::ThreadLocalRef(_) => self.check_op(ops::ThreadLocalAccess),
 
  Rvalue::Use(_)
@@ -451,18 +451,15 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
  | Rvalue::Discriminant(..)
  | Rvalue::Len(_) => {}
 
- Rvalue::Aggregate(ref kind, ..) => {
- if let AggregateKind::Generator(def_id, ..) = kind.as_ref() {
- if let Some(generator_kind) = self.tcx.generator_kind(def_id.to_def_id()) {
- if matches!(generator_kind, hir::GeneratorKind::Async(..)) {
- self.check_op(ops::Generator(generator_kind));
- }
- }
+ Rvalue::Aggregate(kind, ..) => {
+ if let AggregateKind::Generator(def_id, ..) = kind.as_ref()
+ && let Some(generator_kind @ hir::GeneratorKind::Async(..)) = self.tcx.generator_kind(def_id.to_def_id())
+ {
+ self.check_op(ops::Generator(generator_kind));
  }
  }
 
- Rvalue::Ref(_, kind @ BorrowKind::Mut { .. }, ref place)
- | Rvalue::Ref(_, kind @ BorrowKind::Unique, ref place) => {
+ Rvalue::Ref(_, kind @ (BorrowKind::Mut { .. } | BorrowKind::Unique), place) => {
  let ty = place.ty(self.body, self.tcx).ty;
  let is_allowed = match ty.kind() {
  // Inside a `static mut`, `&mut [...]` is allowed.
@@ -491,12 +488,12 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
  }
  }
 
- Rvalue::AddressOf(Mutability::Mut, ref place) => {
+ Rvalue::AddressOf(Mutability::Mut, place) => {
  self.check_mut_borrow(place.local, hir::BorrowKind::Raw)
  }
 
- Rvalue::Ref(_, BorrowKind::Shared | BorrowKind::Shallow, ref place)
- | Rvalue::AddressOf(Mutability::Not, ref place) => {
+ Rvalue::Ref(_, BorrowKind::Shared | BorrowKind::Shallow, place)
+ | Rvalue::AddressOf(Mutability::Not, place) => {
  let borrowed_place_has_mut_interior = qualifs::in_place::<HasMutInterior, _>(
  &self.ccx,
  &mut |local| self.qualifs.has_mut_interior(self.ccx, local, location),
@@ -564,7 +561,7 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
  Rvalue::NullaryOp(NullOp::SizeOf | NullOp::AlignOf, _) => {}
  Rvalue::ShallowInitBox(_, _) => {}
 
- Rvalue::UnaryOp(_, ref operand) => {
+ Rvalue::UnaryOp(_, operand) => {
  let ty = operand.ty(self.body, self.tcx);
  if is_int_bool_or_char(ty) {
  // Int, bool, and char operations are fine.
@@ -575,8 +572,8 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
  }
  }
 
- Rvalue::BinaryOp(op, box (ref lhs, ref rhs))
- | Rvalue::CheckedBinaryOp(op, box (ref lhs, ref rhs)) => {
+ Rvalue::BinaryOp(op, box (lhs, rhs))
+ | Rvalue::CheckedBinaryOp(op, box (lhs, rhs)) => {
  let lhs_ty = lhs.ty(self.body, self.tcx);
  let rhs_ty = rhs.ty(self.body, self.tcx);
 
@@ -585,13 +582,16 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
  } else if lhs_ty.is_fn_ptr() || lhs_ty.is_unsafe_ptr() {
  assert_eq!(lhs_ty, rhs_ty);
  assert!(
- op == BinOp::Eq
- || op == BinOp::Ne
- || op == BinOp::Le
- || op == BinOp::Lt
- || op == BinOp::Ge
- || op == BinOp::Gt
- || op == BinOp::Offset
+ matches!(
+ op,
+ BinOp::Eq
+ | BinOp::Ne
+ | BinOp::Le
+ | BinOp::Lt
+ | BinOp::Ge
+ | BinOp::Gt
+ | BinOp::Offset
+ )
  );
 
  self.check_op(ops::RawPtrComparison);

compiler/rustc_const_eval/src/transform/promote_consts.rs

@@ -133,7 +133,7 @@ impl<'tcx> Visitor<'tcx> for Collector<'_, 'tcx> {
  }
  _ => { /* mark as unpromotable below */ }
  }
- } else if let TempState::Defined { ref mut uses, .. } = *temp {
+ } else if let TempState::Defined { uses, .. } = temp {
  // We always allow borrows, even mutable ones, as we need
  // to promote mutable borrows of some ZSTs e.g., `&mut []`.
  let allowed_use = match context {
@@ -748,7 +748,7 @@ impl<'a, 'tcx> Promoter<'a, 'tcx> {
  if loc.statement_index < num_stmts {
  let (mut rvalue, source_info) = {
  let statement = &mut self.source[loc.block].statements[loc.statement_index];
- let StatementKind::Assign(box (_, ref mut rhs)) = statement.kind else {
+ let StatementKind::Assign(box (_, rhs)) = &mut statement.kind else {
  span_bug!(
  statement.source_info.span,
  "{:?} is not an assignment",
@@ -778,9 +778,9 @@ impl<'a, 'tcx> Promoter<'a, 'tcx> {
  self.source[loc.block].terminator().clone()
  } else {
  let terminator = self.source[loc.block].terminator_mut();
- let target = match terminator.kind {
- TerminatorKind::Call { target: Some(target), .. } => target,
- ref kind => {
+ let target = match &terminator.kind {
+ TerminatorKind::Call { target: Some(target), .. } => *target,
+ kind => {
  span_bug!(terminator.source_info.span, "{:?} not promotable", kind);
  }
  };
@@ -814,7 +814,7 @@ impl<'a, 'tcx> Promoter<'a, 'tcx> {
  ..terminator
  };
  }
- ref kind => {
+ kind => {
  span_bug!(terminator.source_info.span, "{:?} not promotable", kind);
  }
  };
@@ -847,54 +847,50 @@ impl<'a, 'tcx> Promoter<'a, 'tcx> {
  let local_decls = &mut self.source.local_decls;
  let loc = candidate.location;
  let statement = &mut blocks[loc.block].statements[loc.statement_index];
- match statement.kind {
- StatementKind::Assign(box (
- _,
- Rvalue::Ref(ref mut region, borrow_kind, ref mut place),
- )) => {
- // Use the underlying local for this (necessarily interior) borrow.
- let ty = local_decls[place.local].ty;
- let span = statement.source_info.span;
-
- let ref_ty = tcx.mk_ref(
- tcx.lifetimes.re_erased,
- ty::TypeAndMut { ty, mutbl: borrow_kind.to_mutbl_lossy() },
- );
+ let StatementKind::Assign(box (_, Rvalue::Ref(region, borrow_kind, place))) = &mut statement.kind else {
+ bug!()
+ };
 
- *region = tcx.lifetimes.re_erased;
-
- let mut projection = vec![PlaceElem::Deref];
- projection.extend(place.projection);
- place.projection = tcx.intern_place_elems(&projection);
-
- // Create a temp to hold the promoted reference.
- // This is because `*r` requires `r` to be a local,
- // otherwise we would use the `promoted` directly.
- let mut promoted_ref = LocalDecl::new(ref_ty, span);
- promoted_ref.source_info = statement.source_info;
- let promoted_ref = local_decls.push(promoted_ref);
- assert_eq!(self.temps.push(TempState::Unpromotable), promoted_ref);
-
- let promoted_ref_statement = Statement {
- source_info: statement.source_info,
- kind: StatementKind::Assign(Box::new((
- Place::from(promoted_ref),
- Rvalue::Use(promoted_operand(ref_ty, span)),
- ))),
- };
- self.extra_statements.push((loc, promoted_ref_statement));
-
- Rvalue::Ref(
- tcx.lifetimes.re_erased,
- borrow_kind,
- Place {
- local: mem::replace(&mut place.local, promoted_ref),
- projection: List::empty(),
- },
- )
- }
- _ => bug!(),
- }
+ // Use the underlying local for this (necessarily interior) borrow.
+ let ty = local_decls[place.local].ty;
+ let span = statement.source_info.span;
+
+ let ref_ty = tcx.mk_ref(
+ tcx.lifetimes.re_erased,
+ ty::TypeAndMut { ty, mutbl: borrow_kind.to_mutbl_lossy() },
+ );
+
+ *region = tcx.lifetimes.re_erased;
+
+ let mut projection = vec![PlaceElem::Deref];
+ projection.extend(place.projection);
+ place.projection = tcx.intern_place_elems(&projection);
+
+ // Create a temp to hold the promoted reference.
+ // This is because `*r` requires `r` to be a local,
+ // otherwise we would use the `promoted` directly.
+ let mut promoted_ref = LocalDecl::new(ref_ty, span);
+ promoted_ref.source_info = statement.source_info;
+ let promoted_ref = local_decls.push(promoted_ref);
+ assert_eq!(self.temps.push(TempState::Unpromotable), promoted_ref);
+
+ let promoted_ref_statement = Statement {
+ source_info: statement.source_info,
+ kind: StatementKind::Assign(Box::new((
+ Place::from(promoted_ref),
+ Rvalue::Use(promoted_operand(ref_ty, span)),
+ ))),
+ };
+ self.extra_statements.push((loc, promoted_ref_statement));
+
+ Rvalue::Ref(
+ tcx.lifetimes.re_erased,
+ *borrow_kind,
+ Place {
+ local: mem::replace(&mut place.local, promoted_ref),
+ projection: List::empty(),
+ },
+ )
  };
 
  assert_eq!(self.new_block(), START_BLOCK);

compiler/rustc_data_structures/src/graph/implementation/tests.rs

@@ -70,8 +70,8 @@ fn test_adjacent_edges<N: PartialEq + Debug, E: PartialEq + Debug>(
  "counter={:?} expected={:?} edge_index={:?} edge={:?}",
  counter, expected_incoming[counter], edge_index, edge
  );
- match expected_incoming[counter] {
- (ref e, ref n) => {
+ match &expected_incoming[counter] {
+ (e, n) => {
  assert!(e == &edge.data);
  assert!(n == graph.node_data(edge.source()));
  assert!(start_index == edge.target);
@@ -88,8 +88,8 @@ fn test_adjacent_edges<N: PartialEq + Debug, E: PartialEq + Debug>(
  "counter={:?} expected={:?} edge_index={:?} edge={:?}",
  counter, expected_outgoing[counter], edge_index, edge
  );
- match expected_outgoing[counter] {
- (ref e, ref n) => {
+ match &expected_outgoing[counter] {
+ (e, n) => {
  assert!(e == &edge.data);
  assert!(start_index == edge.source);
  assert!(n == graph.node_data(edge.target));