Rollup merge of #105050 - WaffleLapkin:uselessrefign, r=jyn514

Remove useless borrows and derefs

They are nothing more than noise.
<sub>These are not all of them, but my clippy started crashing (stack overflow), so rip :(</sub>

compiler/rustc_abi/src/layout.rs

@@ -354,7 +354,7 @@ pub trait LayoutCalculator {
  if !always_sized { StructKind::MaybeUnsized } else { StructKind::AlwaysSized }
  };
 
- let mut st = self.univariant(dl, &variants[v], &repr, kind)?;
+ let mut st = self.univariant(dl, &variants[v], repr, kind)?;
  st.variants = Variants::Single { index: v };
 
  if is_unsafe_cell {
@@ -457,7 +457,7 @@ pub trait LayoutCalculator {
  let mut variant_layouts = variants
  .iter_enumerated()
  .map(|(j, v)| {
- let mut st = self.univariant(dl, v, &repr, StructKind::AlwaysSized)?;
+ let mut st = self.univariant(dl, v, repr, StructKind::AlwaysSized)?;
  st.variants = Variants::Single { index: j };
 
  align = align.max(st.align);
@@ -647,8 +647,8 @@ pub trait LayoutCalculator {
  .map(|(i, field_layouts)| {
  let mut st = self.univariant(
  dl,
- &field_layouts,
- &repr,
+ field_layouts,
+ repr,
  StructKind::Prefixed(min_ity.size(), prefix_align),
  )?;
  st.variants = Variants::Single { index: i };
@@ -755,7 +755,7 @@ pub trait LayoutCalculator {
  // Try to use a ScalarPair for all tagged enums.
  let mut common_prim = None;
  let mut common_prim_initialized_in_all_variants = true;
- for (field_layouts, layout_variant) in iter::zip(&*variants, &layout_variants) {
+ for (field_layouts, layout_variant) in iter::zip(variants, &layout_variants) {
  let FieldsShape::Arbitrary { ref offsets, .. } = layout_variant.fields else {
  panic!();
  };

compiler/rustc_ast/src/ast.rs

@@ -1175,7 +1175,7 @@ impl Expr {
  pub fn peel_parens(&self) -> &Expr {
  let mut expr = self;
  while let ExprKind::Paren(inner) = &expr.kind {
- expr = &inner;
+ expr = inner;
  }
  expr
  }
@@ -2023,7 +2023,7 @@ impl Ty {
  pub fn peel_refs(&self) -> &Self {
  let mut final_ty = self;
  while let TyKind::Rptr(_, MutTy { ty, .. }) = &final_ty.kind {
- final_ty = &ty;
+ final_ty = ty;
  }
  final_ty
  }

compiler/rustc_ast/src/mut_visit.rs

@@ -740,8 +740,7 @@ pub fn visit_token<T: MutVisitor>(t: &mut Token, vis: &mut T) {
  return; // Avoid visiting the span for the second time.
  }
  token::Interpolated(nt) => {
- let mut nt = Lrc::make_mut(nt);
- visit_nonterminal(&mut nt, vis);
+ visit_nonterminal(Lrc::make_mut(nt), vis);
  }
  _ => {}
  }

compiler/rustc_ast/src/tokenstream.rs

@@ -64,7 +64,7 @@ impl TokenTree {
  match (self, other) {
  (TokenTree::Token(token, _), TokenTree::Token(token2, _)) => token.kind == token2.kind,
  (TokenTree::Delimited(_, delim, tts), TokenTree::Delimited(_, delim2, tts2)) => {
- delim == delim2 && tts.eq_unspanned(&tts2)
+ delim == delim2 && tts.eq_unspanned(tts2)
  }
  _ => false,
  }
@@ -402,7 +402,7 @@ impl TokenStream {
  let mut t1 = self.trees();
  let mut t2 = other.trees();
  for (t1, t2) in iter::zip(&mut t1, &mut t2) {
- if !t1.eq_unspanned(&t2) {
+ if !t1.eq_unspanned(t2) {
  return false;
  }
  }
@@ -475,7 +475,7 @@ impl TokenStream {
  token::Interpolated(nt) => TokenTree::Delimited(
  DelimSpan::from_single(token.span),
  Delimiter::Invisible,
- TokenStream::from_nonterminal_ast(&nt).flattened(),
+ TokenStream::from_nonterminal_ast(nt).flattened(),
  ),
  _ => TokenTree::Token(token.clone(), spacing),
  }
@@ -511,7 +511,7 @@ impl TokenStream {
  fn try_glue_to_last(vec: &mut Vec<TokenTree>, tt: &TokenTree) -> bool {
  if let Some(TokenTree::Token(last_tok, Spacing::Joint)) = vec.last()
  && let TokenTree::Token(tok, spacing) = tt
- && let Some(glued_tok) = last_tok.glue(&tok)
+ && let Some(glued_tok) = last_tok.glue(tok)
  {
  // ...then overwrite the last token tree in `vec` with the
  // glued token, and skip the first token tree from `stream`.

compiler/rustc_ast/src/util/comments.rs

@@ -110,7 +110,7 @@ pub fn beautify_doc_string(data: Symbol, kind: CommentKind) -> Symbol {
  } else {
  &mut lines
  };
- if let Some(horizontal) = get_horizontal_trim(&lines, kind) {
+ if let Some(horizontal) = get_horizontal_trim(lines, kind) {
  changes = true;
  // remove a "[ \t]*\*" block from each line, if possible
  for line in lines.iter_mut() {
@@ -147,7 +147,7 @@ fn all_whitespace(s: &str, col: CharPos) -> Option<usize> {
 
 fn trim_whitespace_prefix(s: &str, col: CharPos) -> &str {
  let len = s.len();
- match all_whitespace(&s, col) {
+ match all_whitespace(s, col) {
  Some(col) => {
  if col < len {
  &s[col..]

compiler/rustc_ast/src/util/literal.rs

@@ -52,14 +52,14 @@ impl LitKind {
  // new symbol because the string in the LitKind is different to the
  // string in the token.
  let s = symbol.as_str();
- let symbol = if s.contains(&['\\', '\r']) {
+ let symbol = if s.contains(['\\', '\r']) {
  let mut buf = String::with_capacity(s.len());
  let mut error = Ok(());
  // Force-inlining here is aggressive but the closure is
  // called on every char in the string, so it can be
  // hot in programs with many long strings.
  unescape_literal(
- &s,
+ s,
  Mode::Str,
  &mut #[inline(always)]
  |_, unescaped_char| match unescaped_char {
@@ -85,7 +85,7 @@ impl LitKind {
  if s.contains('\r') {
  let mut buf = String::with_capacity(s.len());
  let mut error = Ok(());
- unescape_literal(&s, Mode::RawStr, &mut |_, unescaped_char| {
+ unescape_literal(s, Mode::RawStr, &mut |_, unescaped_char| {
  match unescaped_char {
  Ok(c) => buf.push(c),
  Err(err) => {
@@ -106,7 +106,7 @@ impl LitKind {
  let s = symbol.as_str();
  let mut buf = Vec::with_capacity(s.len());
  let mut error = Ok(());
- unescape_literal(&s, Mode::ByteStr, &mut |_, c| match c {
+ unescape_literal(s, Mode::ByteStr, &mut |_, c| match c {
  Ok(c) => buf.push(byte_from_char(c)),
  Err(err) => {
  if err.is_fatal() {
@@ -122,7 +122,7 @@ impl LitKind {
  let bytes = if s.contains('\r') {
  let mut buf = Vec::with_capacity(s.len());
  let mut error = Ok(());
- unescape_literal(&s, Mode::RawByteStr, &mut |_, c| match c {
+ unescape_literal(s, Mode::RawByteStr, &mut |_, c| match c {
  Ok(c) => buf.push(byte_from_char(c)),
  Err(err) => {
  if err.is_fatal() {

compiler/rustc_ast/src/util/parser.rs

@@ -384,7 +384,7 @@ pub fn contains_exterior_struct_lit(value: &ast::Expr) -> bool {
  | ast::ExprKind::AssignOp(_, lhs, rhs)
  | ast::ExprKind::Binary(_, lhs, rhs) => {
  // X { y: 1 } + X { y: 2 }
- contains_exterior_struct_lit(&lhs) || contains_exterior_struct_lit(&rhs)
+ contains_exterior_struct_lit(lhs) || contains_exterior_struct_lit(rhs)
  }
  ast::ExprKind::Await(x)
  | ast::ExprKind::Unary(_, x)
@@ -393,12 +393,12 @@ pub fn contains_exterior_struct_lit(value: &ast::Expr) -> bool {
  | ast::ExprKind::Field(x, _)
  | ast::ExprKind::Index(x, _) => {
  // &X { y: 1 }, X { y: 1 }.y
- contains_exterior_struct_lit(&x)
+ contains_exterior_struct_lit(x)
  }
 
  ast::ExprKind::MethodCall(box ast::MethodCall { receiver, .. }) => {
  // X { y: 1 }.bar(...)
- contains_exterior_struct_lit(&receiver)
+ contains_exterior_struct_lit(receiver)
  }
 
  _ => false,

compiler/rustc_ast/src/util/unicode.rs

@@ -17,7 +17,7 @@ pub fn contains_text_flow_control_chars(s: &str) -> bool {
  // U+2069 - E2 81 A9
  let mut bytes = s.as_bytes();
  loop {
- match core::slice::memchr::memchr(0xE2, &bytes) {
+ match core::slice::memchr::memchr(0xE2, bytes) {
  Some(idx) => {
  // bytes are valid UTF-8 -> E2 must be followed by two bytes
  let ch = &bytes[idx..idx + 3];

compiler/rustc_ast_pretty/src/pprust/state.rs

@@ -515,7 +515,7 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
  ast::MetaItemKind::List(ref items) => {
  self.print_path(&item.path, false, 0);
  self.popen();
- self.commasep(Consistent, &items, |s, i| s.print_meta_list_item(i));
+ self.commasep(Consistent, items, |s, i| s.print_meta_list_item(i));
  self.pclose();
  }
  }
@@ -532,7 +532,7 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
  fn print_tt(&mut self, tt: &TokenTree, convert_dollar_crate: bool) {
  match tt {
  TokenTree::Token(token, _) => {
- let token_str = self.token_to_string_ext(&token, convert_dollar_crate);
+ let token_str = self.token_to_string_ext(token, convert_dollar_crate);
  self.word(token_str);
  if let token::DocComment(..) = token.kind {
  self.hardbreak()
@@ -994,7 +994,7 @@ impl<'a> State<'a> {
  ast::AssocConstraintKind::Bound { bounds } => {
  if !bounds.is_empty() {
  self.word_nbsp(":");
- self.print_type_bounds(&bounds);
+ self.print_type_bounds(bounds);
  }
  }
  }
@@ -1031,7 +1031,7 @@ impl<'a> State<'a> {
  }
  ast::TyKind::Tup(ref elts) => {
  self.popen();
- self.commasep(Inconsistent, &elts, |s, ty| s.print_type(ty));
+ self.commasep(Inconsistent, elts, |s, ty| s.print_type(ty));
  if elts.len() == 1 {
  self.word(",");
  }
@@ -1250,7 +1250,7 @@ impl<'a> State<'a> {
 
  self.popen();
  self.commasep(Consistent, &args, |s, arg| match arg {
- AsmArg::Template(template) => s.print_string(&template, ast::StrStyle::Cooked),
+ AsmArg::Template(template) => s.print_string(template, ast::StrStyle::Cooked),
  AsmArg::Operand(op) => {
  let print_reg_or_class = |s: &mut Self, r: &InlineAsmRegOrRegClass| match r {
  InlineAsmRegOrRegClass::Reg(r) => s.print_symbol(*r, ast::StrStyle::Cooked),
@@ -1420,11 +1420,11 @@ impl<'a> State<'a> {
  self.print_path(path, true, 0);
  }
  self.popen();
- self.commasep(Inconsistent, &elts, |s, p| s.print_pat(p));
+ self.commasep(Inconsistent, elts, |s, p| s.print_pat(p));
  self.pclose();
  }
  PatKind::Or(ref pats) => {
- self.strsep("|", true, Inconsistent, &pats, |s, p| s.print_pat(p));
+ self.strsep("|", true, Inconsistent, pats, |s, p| s.print_pat(p));
  }
  PatKind::Path(None, ref path) => {
  self.print_path(path, true, 0);
@@ -1446,7 +1446,7 @@ impl<'a> State<'a> {
  }
  self.commasep_cmnt(
  Consistent,
- &fields,
+ fields,
  |s, f| {
  s.cbox(INDENT_UNIT);
  if !f.is_shorthand {
@@ -1471,7 +1471,7 @@ impl<'a> State<'a> {
  }
  PatKind::Tuple(ref elts) => {
  self.popen();
- self.commasep(Inconsistent, &elts, |s, p| s.print_pat(p));
+ self.commasep(Inconsistent, elts, |s, p| s.print_pat(p));
  if elts.len() == 1 {
  self.word(",");
  }
@@ -1494,7 +1494,7 @@ impl<'a> State<'a> {
  self.print_pat(inner);
  }
  }
- PatKind::Lit(ref e) => self.print_expr(&**e),
+ PatKind::Lit(ref e) => self.print_expr(e),
  PatKind::Range(ref begin, ref end, Spanned { node: ref end_kind, .. }) => {
  if let Some(e) = begin {
  self.print_expr(e);
@@ -1510,7 +1510,7 @@ impl<'a> State<'a> {
  }
  PatKind::Slice(ref elts) => {
  self.word("[");
- self.commasep(Inconsistent, &elts, |s, p| s.print_pat(p));
+ self.commasep(Inconsistent, elts, |s, p| s.print_pat(p));
  self.word("]");
  }
  PatKind::Rest => self.word(".."),
@@ -1596,7 +1596,7 @@ impl<'a> State<'a> {
 
  self.word("<");
 
- self.commasep(Inconsistent, &generic_params, |s, param| {
+ self.commasep(Inconsistent, generic_params, |s, param| {
  s.print_outer_attributes_inline(&param.attrs);
 
  match param.kind {

compiler/rustc_ast_pretty/src/pprust/state/expr.rs

@@ -305,15 +305,15 @@ impl<'a> State<'a> {
  self.print_expr_tup(exprs);
  }
  ast::ExprKind::Call(ref func, ref args) => {
- self.print_expr_call(func, &args);
+ self.print_expr_call(func, args);
  }
  ast::ExprKind::MethodCall(box ast::MethodCall {
  ref seg,
  ref receiver,
  ref args,
  ..
  }) => {
- self.print_expr_method_call(seg, &receiver, &args);
+ self.print_expr_method_call(seg, receiver, args);
  }
  ast::ExprKind::Binary(op, ref lhs, ref rhs) => {
  self.print_expr_binary(op, lhs, rhs);
@@ -613,7 +613,7 @@ impl<'a> State<'a> {
  match binder {
  ast::ClosureBinder::NotPresent => {}
  ast::ClosureBinder::For { generic_params, .. } => {
- self.print_formal_generic_params(&generic_params)
+ self.print_formal_generic_params(generic_params)
  }
  }
  }

compiler/rustc_data_structures/src/intern.rs

@@ -72,7 +72,7 @@ impl<'a, T: PartialOrd> PartialOrd for Interned<'a, T> {
  if ptr::eq(self.0, other.0) {
  Some(Ordering::Equal)
  } else {
- let res = self.0.partial_cmp(&other.0);
+ let res = self.0.partial_cmp(other.0);
  debug_assert_ne!(res, Some(Ordering::Equal));
  res
  }
@@ -86,7 +86,7 @@ impl<'a, T: Ord> Ord for Interned<'a, T> {
  if ptr::eq(self.0, other.0) {
  Ordering::Equal
  } else {
- let res = self.0.cmp(&other.0);
+ let res = self.0.cmp(other.0);
  debug_assert_ne!(res, Ordering::Equal);
  res
  }

compiler/rustc_data_structures/src/memmap.rs

@@ -36,7 +36,7 @@ impl Deref for Mmap {
 
  #[inline]
  fn deref(&self) -> &[u8] {
- &*self.0
+ &self.0
  }
 }
 
@@ -96,13 +96,13 @@ impl Deref for MmapMut {
 
  #[inline]
  fn deref(&self) -> &[u8] {
- &*self.0
+ &self.0
  }
 }
 
 impl DerefMut for MmapMut {
  #[inline]
  fn deref_mut(&mut self) -> &mut [u8] {
- &mut *self.0
+ &mut self.0
  }
 }