Remove more ref patterns from the compiler

compiler/rustc_attr/src/builtin.rs

@@ -277,8 +277,7 @@ where
  allowed_through_unstable_modules = true;
  }
  // attributes with data
- else if let Some(MetaItem { kind: MetaItemKind::List(ref metas), .. }) = meta {
- let meta = meta.as_ref().unwrap();
+ else if let Some(meta @ MetaItem { kind: MetaItemKind::List(metas), .. }) = &meta {
  let get = |meta: &MetaItem, item: &mut Option<Symbol>| {
  if item.is_some() {
  handle_errors(
@@ -533,25 +532,24 @@ where
 
  // Merge the const-unstable info into the stability info
  if promotable {
- if let Some((ref mut stab, _)) = const_stab {
- stab.promotable = promotable;
- } else {
- sess.emit_err(session_diagnostics::RustcPromotablePairing { span: item_sp });
+ match &mut const_stab {
+ Some((stab, _)) => stab.promotable = promotable,
+ _ => _ = sess.emit_err(session_diagnostics::RustcPromotablePairing { span: item_sp }),
  }
  }
 
  if allowed_through_unstable_modules {
- if let Some((
- Stability {
- level: StabilityLevel::Stable { ref mut allowed_through_unstable_modules, .. },
- ..
- },
- _,
- )) = stab
- {
- *allowed_through_unstable_modules = true;
- } else {
- sess.emit_err(session_diagnostics::RustcAllowedUnstablePairing { span: item_sp });
+ match &mut stab {
+ Some((
+ Stability {
+  level: StabilityLevel::Stable { allowed_through_unstable_modules, .. },
+  ..
+  },
+  _,
+  )) => *allowed_through_unstable_modules = true,
+ _ => {
+  sess.emit_err(session_diagnostics::RustcAllowedUnstablePairing { span: item_sp });
+ }
  }
  }
 
@@ -654,8 +652,8 @@ pub fn eval_condition(
  features: Option<&Features>,
  eval: &mut impl FnMut(Condition) -> bool,
 ) -> bool {
- match cfg.kind {
- ast::MetaItemKind::List(ref mis) if cfg.name_or_empty() == sym::version => {
+ match &cfg.kind {
+ ast::MetaItemKind::List(mis) if cfg.name_or_empty() == sym::version => {
  try_gate_cfg(sym::version, cfg.span, sess, features);
  let (min_version, span) = match &mis[..] {
  [NestedMetaItem::Lit(MetaItemLit { kind: LitKind::Str(sym, ..), span, .. })] => {
@@ -688,7 +686,7 @@ pub fn eval_condition(
  rustc_version >= min_version
  }
  }
- ast::MetaItemKind::List(ref mis) => {
+ ast::MetaItemKind::List(mis) => {
  for mi in mis.iter() {
  if !mi.is_meta_item() {
  handle_errors(
@@ -759,7 +757,7 @@ pub fn eval_condition(
  sess.emit_err(session_diagnostics::CfgPredicateIdentifier { span: cfg.path.span });
  true
  }
- MetaItemKind::NameValue(ref lit) if !lit.kind.is_str() => {
+ MetaItemKind::NameValue(lit) if !lit.kind.is_str() => {
  handle_errors(
  sess,
  lit.span,
@@ -1036,52 +1034,58 @@ pub fn parse_repr_attr(sess: &Session, attr: &Attribute) -> Vec<ReprAttr> {
  });
  }
  } else if let Some(meta_item) = item.meta_item() {
- if let MetaItemKind::NameValue(ref value) = meta_item.kind {
- if meta_item.has_name(sym::align) || meta_item.has_name(sym::packed) {
- let name = meta_item.name_or_empty().to_ident_string();
- recognised = true;
- sess.emit_err(session_diagnostics::IncorrectReprFormatGeneric {
- span: item.span(),
- repr_arg: &name,
- cause: IncorrectReprFormatGenericCause::from_lit_kind(
- item.span(),
- &value.kind,
- &name,
- ),
- });
- } else if matches!(
- meta_item.name_or_empty(),
- sym::C | sym::simd | sym::transparent
- ) || int_type_of_word(meta_item.name_or_empty()).is_some()
- {
- recognised = true;
- sess.emit_err(session_diagnostics::InvalidReprHintNoValue {
- span: meta_item.span,
- name: meta_item.name_or_empty().to_ident_string(),
- });
+ match &meta_item.kind {
+ MetaItemKind::NameValue(value) => {
+ if meta_item.has_name(sym::align) || meta_item.has_name(sym::packed) {
+ let name = meta_item.name_or_empty().to_ident_string();
+ recognised = true;
+ sess.emit_err(session_diagnostics::IncorrectReprFormatGeneric {
+ span: item.span(),
+ repr_arg: &name,
+ cause: IncorrectReprFormatGenericCause::from_lit_kind(
+ item.span(),
+ &value.kind,
+ &name,
+ ),
+ });
+ } else if matches!(
+ meta_item.name_or_empty(),
+ sym::C | sym::simd | sym::transparent
+ ) || int_type_of_word(meta_item.name_or_empty()).is_some()
+ {
+ recognised = true;
+ sess.emit_err(session_diagnostics::InvalidReprHintNoValue {
+ span: meta_item.span,
+ name: meta_item.name_or_empty().to_ident_string(),
+ });
+ }
  }
- } else if let MetaItemKind::List(_) = meta_item.kind {
- if meta_item.has_name(sym::align) {
- recognised = true;
- sess.emit_err(session_diagnostics::IncorrectReprFormatAlignOneArg {
- span: meta_item.span,
- });
- } else if meta_item.has_name(sym::packed) {
- recognised = true;
- sess.emit_err(session_diagnostics::IncorrectReprFormatPackedOneOrZeroArg {
- span: meta_item.span,
- });
- } else if matches!(
- meta_item.name_or_empty(),
- sym::C | sym::simd | sym::transparent
- ) || int_type_of_word(meta_item.name_or_empty()).is_some()
- {
- recognised = true;
- sess.emit_err(session_diagnostics::InvalidReprHintNoParen {
- span: meta_item.span,
- name: meta_item.name_or_empty().to_ident_string(),
- });
+ MetaItemKind::List(_) => {
+ if meta_item.has_name(sym::align) {
+ recognised = true;
+ sess.emit_err(session_diagnostics::IncorrectReprFormatAlignOneArg {
+ span: meta_item.span,
+ });
+ } else if meta_item.has_name(sym::packed) {
+ recognised = true;
+ sess.emit_err(
+ session_diagnostics::IncorrectReprFormatPackedOneOrZeroArg {
+ span: meta_item.span,
+ },
+ );
+ } else if matches!(
+ meta_item.name_or_empty(),
+ sym::C | sym::simd | sym::transparent
+ ) || int_type_of_word(meta_item.name_or_empty()).is_some()
+ {
+ recognised = true;
+ sess.emit_err(session_diagnostics::InvalidReprHintNoParen {
+ span: meta_item.span,
+ name: meta_item.name_or_empty().to_ident_string(),
+ });
+ }
  }
+ _ => (),
  }
  }
  if !recognised {

compiler/rustc_borrowck/src/borrow_set.rs

@@ -198,7 +198,7 @@ impl<'a, 'tcx> Visitor<'tcx> for GatherBorrows<'a, 'tcx> {
  rvalue: &mir::Rvalue<'tcx>,
  location: mir::Location,
  ) {
- if let mir::Rvalue::Ref(region, kind, ref borrowed_place) = *rvalue {
+ if let &mir::Rvalue::Ref(region, kind, borrowed_place) = rvalue {
  if borrowed_place.ignore_borrow(self.tcx, self.body, &self.locals_state_at_exit) {
  debug!("ignoring_borrow of {:?}", borrowed_place);
  return;
@@ -211,7 +211,7 @@ impl<'a, 'tcx> Visitor<'tcx> for GatherBorrows<'a, 'tcx> {
  region,
  reserve_location: location,
  activation_location: TwoPhaseActivation::NotTwoPhase,
- borrowed_place: *borrowed_place,
+ borrowed_place,
  assigned_place: *assigned_place,
  };
  let (idx, _) = self.location_map.insert_full(location, borrow);
@@ -273,14 +273,14 @@ impl<'a, 'tcx> Visitor<'tcx> for GatherBorrows<'a, 'tcx> {
  }
 
  fn visit_rvalue(&mut self, rvalue: &mir::Rvalue<'tcx>, location: mir::Location) {
- if let mir::Rvalue::Ref(region, kind, ref place) = *rvalue {
+ if let &mir::Rvalue::Ref(region, kind, place) = rvalue {
  // double-check that we already registered a BorrowData for this
 
  let borrow_data = &self.location_map[&location];
  assert_eq!(borrow_data.reserve_location, location);
  assert_eq!(borrow_data.kind, kind);
  assert_eq!(borrow_data.region, region.to_region_vid());
- assert_eq!(borrow_data.borrowed_place, *place);
+ assert_eq!(borrow_data.borrowed_place, place);
  }
 
  self.super_rvalue(rvalue, location)

compiler/rustc_borrowck/src/dataflow.rs

@@ -358,9 +358,9 @@ impl<'tcx> rustc_mir_dataflow::GenKillAnalysis<'tcx> for Borrows<'_, 'tcx> {
  stmt: &mir::Statement<'tcx>,
  location: Location,
  ) {
- match stmt.kind {
- mir::StatementKind::Assign(box (lhs, ref rhs)) => {
- if let mir::Rvalue::Ref(_, _, place) = *rhs {
+ match &stmt.kind {
+ mir::StatementKind::Assign(box (lhs, rhs)) => {
+ if let mir::Rvalue::Ref(_, _, place) = rhs {
  if place.ignore_borrow(
  self.tcx,
  self.body,
@@ -377,13 +377,13 @@ impl<'tcx> rustc_mir_dataflow::GenKillAnalysis<'tcx> for Borrows<'_, 'tcx> {
 
  // Make sure there are no remaining borrows for variables
  // that are assigned over.
- self.kill_borrows_on_place(trans, lhs);
+ self.kill_borrows_on_place(trans, *lhs);
  }
 
  mir::StatementKind::StorageDead(local) => {
  // Make sure there are no remaining borrows for locals that
  // are gone out of scope.
- self.kill_borrows_on_place(trans, Place::from(local));
+ self.kill_borrows_on_place(trans, Place::from(*local));
  }
 
  mir::StatementKind::FakeRead(..)

compiler/rustc_borrowck/src/diagnostics/bound_region_errors.rs

@@ -243,9 +243,9 @@ impl<'tcx> TypeOpInfo<'tcx> for PredicateQuery<'tcx> {
  placeholder_region: ty::Region<'tcx>,
  error_region: Option<ty::Region<'tcx>>,
  ) -> Option<DiagnosticBuilder<'tcx, ErrorGuaranteed>> {
- let (ref infcx, key, _) =
+ let (infcx, key, _) =
  mbcx.infcx.tcx.infer_ctxt().build_with_canonical(cause.span, &self.canonical_query);
- let ocx = ObligationCtxt::new(infcx);
+ let ocx = ObligationCtxt::new(&infcx);
  type_op_prove_predicate_with_cause(&ocx, key, cause);
  try_extract_error_from_fulfill_cx(&ocx, placeholder_region, error_region)
  }
@@ -284,9 +284,9 @@ where
  placeholder_region: ty::Region<'tcx>,
  error_region: Option<ty::Region<'tcx>>,
  ) -> Option<DiagnosticBuilder<'tcx, ErrorGuaranteed>> {
- let (ref infcx, key, _) =
+ let (infcx, key, _) =
  mbcx.infcx.tcx.infer_ctxt().build_with_canonical(cause.span, &self.canonical_query);
- let ocx = ObligationCtxt::new(infcx);
+ let ocx = ObligationCtxt::new(&infcx);
 
  // FIXME(lqd): Unify and de-duplicate the following with the actual
  // `rustc_traits::type_op::type_op_normalize` query to allow the span we need in the
@@ -328,9 +328,9 @@ impl<'tcx> TypeOpInfo<'tcx> for AscribeUserTypeQuery<'tcx> {
  placeholder_region: ty::Region<'tcx>,
  error_region: Option<ty::Region<'tcx>>,
  ) -> Option<DiagnosticBuilder<'tcx, ErrorGuaranteed>> {
- let (ref infcx, key, _) =
+ let (infcx, key, _) =
  mbcx.infcx.tcx.infer_ctxt().build_with_canonical(cause.span, &self.canonical_query);
- let ocx = ObligationCtxt::new(infcx);
+ let ocx = ObligationCtxt::new(&infcx);
  type_op_ascribe_user_type_with_span(&ocx, key, Some(cause.span)).ok()?;
  try_extract_error_from_fulfill_cx(&ocx, placeholder_region, error_region)
  }

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

@@ -265,7 +265,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
  DescribePlaceOpt { including_downcast: true, including_tuple_field: true },
  );
  let note_msg = match opt_name {
- Some(ref name) => format!("`{}`", name),
+ Some(name) => format!("`{}`", name),
  None => "value".to_owned(),
  };
  if self.suggest_borrow_fn_like(&mut err, ty, &move_site_vec, &note_msg) {
@@ -1417,7 +1417,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
  // then just use the normal error. The closure isn't escaping
  // and `move` will not help here.
  (
- Some(ref name),
+ Some(name),
  BorrowExplanation::MustBeValidFor {
  category:
  category @ (ConstraintCategory::Return(_)
@@ -1438,7 +1438,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
  &format!("`{}`", name),
  ),
  (
- ref name,
+ name,
  BorrowExplanation::MustBeValidFor {
  category: ConstraintCategory::Assignment,
  from_closure: false,
@@ -1450,7 +1450,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
  span,
  ..
  },
- ) => self.report_escaping_data(borrow_span, name, upvar_span, upvar_name, span),
+ ) => self.report_escaping_data(borrow_span, &name, upvar_span, upvar_name, span),
  (Some(name), explanation) => self.report_local_value_does_not_live_long_enough(
  location,
  &name,
@@ -2452,7 +2452,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
  // and it'll make sense.
  let location = borrow.reserve_location;
  debug!("annotate_argument_and_return_for_borrow: location={:?}", location);
- if let Some(&Statement { kind: StatementKind::Assign(box (ref reservation, _)), .. }) =
+ if let Some(Statement { kind: StatementKind::Assign(box (reservation, _)), .. }) =
  &self.body[location.block].statements.get(location.statement_index)
  {
  debug!("annotate_argument_and_return_for_borrow: reservation={:?}", reservation);
@@ -2480,8 +2480,8 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
  // Check if our `target` was captured by a closure.
  if let Rvalue::Aggregate(
  box AggregateKind::Closure(def_id, substs),
- ref operands,
- ) = *rvalue
+ operands,
+ ) = rvalue
  {
  for operand in operands {
  let (Operand::Copy(assigned_from) | Operand::Move(assigned_from)) = operand else {
@@ -2505,7 +2505,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
  // into a place then we should annotate the closure in
  // case it ends up being assigned into the return place.
  annotated_closure =
- self.annotate_fn_sig(def_id, substs.as_closure().sig());
+ self.annotate_fn_sig(*def_id, substs.as_closure().sig());
  debug!(
  "annotate_argument_and_return_for_borrow: \
  annotated_closure={:?} assigned_from_local={:?} \

compiler/rustc_borrowck/src/diagnostics/explain_borrow.rs

@@ -469,8 +469,8 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
  } else if self.was_captured_by_trait_object(borrow) {
  LaterUseKind::TraitCapture
  } else if location.statement_index == block.statements.len() {
- if let TerminatorKind::Call { ref func, from_hir_call: true, .. } =
- block.terminator().kind
+ if let TerminatorKind::Call { func, from_hir_call: true, .. } =
+ &block.terminator().kind
  {
  // Just point to the function, to reduce the chance of overlapping spans.
  let function_span = match func {
@@ -515,19 +515,16 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
  // will only ever have one item at any given time, but by using a vector, we can pop from
  // it which simplifies the termination logic.
  let mut queue = vec![location];
- let mut target = if let Some(&Statement {
- kind: StatementKind::Assign(box (ref place, _)),
- ..
- }) = stmt
- {
- if let Some(local) = place.as_local() {
- local
+ let mut target =
+ if let Some(Statement { kind: StatementKind::Assign(box (place, _)), .. }) = stmt {
+  if let Some(local) = place.as_local() {
+  local
+  } else {
+  return false;
+ }
  } else {
  return false;
- }
- } else {
- return false;
- };
+ };
 
  debug!("was_captured_by_trait: target={:?} queue={:?}", target, queue);
  while let Some(current_location) = queue.pop() {