fix lint in rustdoc

Author: estebank

src/librustdoc/clean/mod.rs

@@ -1388,14 +1388,14 @@ pub(crate) fn clean_middle_assoc_item<'tcx>(
                     && let Some(GenericParamDef {
                         kind: GenericParamDefKind::Type { bounds: param_bounds, .. },
                         ..
-                    }) = generics.params.iter_mut().find(|param| &param.name == arg)
+                    }) = generics.params.iter_mut().find(|param| param.name == *arg)
                     {
                         param_bounds.append(bounds);
                     } else if let WherePredicate::RegionPredicate { lifetime: Lifetime(arg), bounds } = &mut pred
                     && let Some(GenericParamDef {
                         kind: GenericParamDefKind::Lifetime { outlives: param_bounds },
                         ..
-                    }) = generics.params.iter_mut().find(|param| &param.name == arg) {
+                    }) = generics.params.iter_mut().find(|param| param.name == *arg) {
                         param_bounds.extend(bounds.drain(..).map(|bound| match bound {
                             GenericBound::Outlives(lifetime) => lifetime,
                             _ => unreachable!(),

src/librustdoc/clean/types.rs

@@ -1483,12 +1483,12 @@ impl Type {
             (Type::Slice(a), Type::Slice(b)) => a.is_same(b, cache),
             (Type::Array(a, al), Type::Array(b, bl)) => al == bl && a.is_same(b, cache),
             (Type::RawPointer(mutability, type_), Type::RawPointer(b_mutability, b_type_)) => {
-                mutability == b_mutability && type_.is_same(b_type_, cache)
+                *mutability == *b_mutability && type_.is_same(b_type_, cache)
             }
             (
                 Type::BorrowedRef { mutability, type_, .. },
                 Type::BorrowedRef { mutability: b_mutability, type_: b_type_, .. },
-            ) => mutability == b_mutability && type_.is_same(b_type_, cache),
+            ) => *mutability == *b_mutability && type_.is_same(b_type_, cache),
             // Placeholders and generics are equal to all other types.
             (Type::Infer, _) | (_, Type::Infer) => true,
             (Type::Generic(_), _) | (_, Type::Generic(_)) => true,

src/librustdoc/html/format.rs

@@ -744,7 +744,7 @@ pub(crate) fn href_relative_parts<'fqp>(
 ) -> Box<dyn Iterator<Item = Symbol> + 'fqp> {
     for (i, (f, r)) in fqp.iter().zip(relative_to_fqp.iter()).enumerate() {
         // e.g. linking to std::iter from std::vec (`dissimilar_part_count` will be 1)
-        if f != r {
+        if *f != *r {
             let dissimilar_part_count = relative_to_fqp.len() - i;
             let fqp_module = &fqp[i..fqp.len()];
             return Box::new(

src/librustdoc/html/render/context.rs

@@ -228,7 +228,7 @@ impl<'tcx> Context<'tcx> {
         } else {
             if let Some(&(ref names, ty)) = self.cache().paths.get(&it.item_id.expect_def_id()) {
                 if self.current.len() + 1 != names.len()
-                    || self.current.iter().zip(names.iter()).any(|(a, b)| a != b)
+                    || self.current.iter().zip(names.iter()).any(|(a, b)| *a != *b)
                 {
                     // We checked that the redirection isn't pointing to the current file,
                     // preventing an infinite redirection loop in the generated