When encountering &SmallImplCopy < &SmallImplCopy, suggest copying

When encountering a binary operation for two `T: Copy` where `T` is as
small as a 64bit pointer, suggest dereferencing the expressions so the
binary operation is inlined.

Mitigate the effects of #105259, particularly when match ergonomics is
involved.

Author: estebank

compiler/rustc_ast/src/token.rs

@@ -894,7 +894,7 @@ impl PartialEq for Nonterminal {
     fn eq(&self, rhs: &Self) -> bool {
         match (self, rhs) {
             (NtIdent(ident_lhs, is_raw_lhs), NtIdent(ident_rhs, is_raw_rhs)) => {
-                ident_lhs == ident_rhs && is_raw_lhs == is_raw_rhs
+                ident_lhs == ident_rhs && *is_raw_lhs == *is_raw_rhs
             }
             (NtLifetime(ident_lhs), NtLifetime(ident_rhs)) => ident_lhs == ident_rhs,
             // FIXME: Assume that all "complex" nonterminal are not equal, we can't compare them

compiler/rustc_ast/src/tokenstream.rs

@@ -65,7 +65,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,
         }

compiler/rustc_ast_lowering/src/lib.rs

@@ -617,7 +617,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         self.impl_trait_defs = current_impl_trait_defs;
         self.impl_trait_bounds = current_impl_trait_bounds;
 
-        debug_assert!(!self.children.iter().any(|(id, _)| id == &def_id));
+        debug_assert!(!self.children.iter().any(|(id, _)| *id == def_id));
         self.children.push((def_id, hir::MaybeOwner::Owner(info)));
     }
 

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -688,8 +688,9 @@ fn check_incompatible_features(sess: &Session) {
         .iter()
         .filter(|&&(f1, f2)| features.enabled(f1) && features.enabled(f2))
     {
-        if let Some((f1_name, f1_span)) = declared_features.clone().find(|(name, _)| name == f1) {
-            if let Some((f2_name, f2_span)) = declared_features.clone().find(|(name, _)| name == f2)
+        if let Some((f1_name, f1_span)) = declared_features.clone().find(|(name, _)| *name == *f1) {
+            if let Some((f2_name, f2_span)) =
+                declared_features.clone().find(|(name, _)| *name == *f2)
             {
                 let spans = vec![f1_span, f2_span];
                 sess.struct_span_err(

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

@@ -2825,7 +2825,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
                 let mut arguments = Vec::new();
                 for (index, argument) in sig.inputs().skip_binder().iter().enumerate() {
                     if let ty::Ref(argument_region, _, _) = argument.kind() {
-                        if argument_region == return_region {
+                        if *argument_region == *return_region {
                             // Need to use the `rustc_middle::ty` types to compare against the
                             // `return_region`. Then use the `rustc_hir` type to get only
                             // the lifetime span.

compiler/rustc_codegen_ssa/src/base.rs

@@ -694,7 +694,7 @@ pub fn codegen_crate<B: ExtraBackendMethods>(
             let cgus: Vec<_> = cgu_reuse
                 .iter()
                 .enumerate()
-                .filter(|&(_, reuse)| reuse == &CguReuse::No)
+                .filter(|&(_, reuse)| *reuse == CguReuse::No)
                 .take(tcx.sess.threads())
                 .collect();
 

compiler/rustc_const_eval/src/interpret/terminator.rs

@@ -258,15 +258,15 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
             (PassMode::Pair(a1, b1), PassMode::Pair(a2, b2)) => {
                 arg_attr_compat(a1, a2) && arg_attr_compat(b1, b2)
             }
-            (PassMode::Cast(c1, pad1), PassMode::Cast(c2, pad2)) => c1 == c2 && pad1 == pad2,
+            (PassMode::Cast(c1, pad1), PassMode::Cast(c2, pad2)) => c1 == c2 && *pad1 == *pad2,
             (
                 PassMode::Indirect { attrs: a1, extra_attrs: None, on_stack: s1 },
                 PassMode::Indirect { attrs: a2, extra_attrs: None, on_stack: s2 },
-            ) => arg_attr_compat(a1, a2) && s1 == s2,
+            ) => arg_attr_compat(a1, a2) && *s1 == *s2,
             (
                 PassMode::Indirect { attrs: a1, extra_attrs: Some(e1), on_stack: s1 },
                 PassMode::Indirect { attrs: a2, extra_attrs: Some(e2), on_stack: s2 },
-            ) => arg_attr_compat(a1, a2) && arg_attr_compat(e1, e2) && s1 == s2,
+            ) => arg_attr_compat(a1, a2) && arg_attr_compat(e1, e2) && *s1 == *s2,
             _ => false,
         };
 

compiler/rustc_errors/src/emitter.rs

@@ -351,7 +351,7 @@ pub trait Emitter: Translate {
             if let Some((macro_kind, name)) = has_macro_spans.first() {
                 // Mark the actual macro this originates from
                 let and_then = if let Some((macro_kind, last_name)) = has_macro_spans.last()
-                    && last_name != name
+                    && *last_name != *name
                 {
                     let descr = macro_kind.descr();
                     format!(
@@ -2753,7 +2753,7 @@ pub fn is_case_difference(sm: &SourceMap, suggested: &str, sp: Span) -> bool {
     let ascii_confusables = &['c', 'f', 'i', 'k', 'o', 's', 'u', 'v', 'w', 'x', 'y', 'z'];
     // All the chars that differ in capitalization are confusable (above):
     let confusable = iter::zip(found.chars(), suggested.chars())
-        .filter(|(f, s)| f != s)
+        .filter(|(f, s)| *f != *s)
         .all(|(f, s)| (ascii_confusables.contains(&f) || ascii_confusables.contains(&s)));
     confusable && found.to_lowercase() == suggested.to_lowercase()
             // FIXME: We sometimes suggest the same thing we already have, which is a

compiler/rustc_expand/src/mbe/transcribe.rs

@@ -123,7 +123,7 @@ pub(super) fn transcribe<'a>(
             if let Frame::Sequence { idx, sep, .. } = stack.last_mut().unwrap() {
                 let (repeat_idx, repeat_len) = repeats.last_mut().unwrap();
                 *repeat_idx += 1;
-                if repeat_idx < repeat_len {
+                if *repeat_idx < *repeat_len {
                     *idx = 0;
                     if let Some(sep) = sep {
                         result.push(TokenTree::Token(sep.clone(), Spacing::Alone));

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -579,7 +579,7 @@ fn gather_gat_bounds<'tcx, T: TypeFoldable<TyCtxt<'tcx>>>(
         for (region_b, region_b_idx) in &regions {
             // Again, skip `'static` because it outlives everything. Also, we trivially
             // know that a region outlives itself.
-            if ty::ReStatic == **region_b || region_a == region_b {
+            if ty::ReStatic == **region_b || *region_a == *region_b {
                 continue;
             }
             if region_known_to_outlive(