Fix format and clippy warnings

Author: JohnTitor

src/bin/cargo-semver.rs

@@ -429,8 +429,8 @@ pub struct WorkInfo<'a> {
 impl<'a> WorkInfo<'a> {
     /// Construct a package/workspace pair for the `manifest_path`
     pub fn local(config: &'a cargo::Config, manifest_path: &Path) -> Result<WorkInfo<'a>> {
-        let workspace = Workspace::new(&manifest_path, config)?;
-        let package = workspace.load(&manifest_path)?;
+        let workspace = Workspace::new(manifest_path, config)?;
+        let package = workspace.load(manifest_path)?;
         Ok(Self { package, workspace })
     }
 
@@ -441,7 +441,7 @@ impl<'a> WorkInfo<'a> {
         &PackageNameAndVersion { name, version }: &PackageNameAndVersion,
     ) -> Result<WorkInfo<'a>> {
         let source = {
-            let source_id = SourceId::crates_io(&config)?;
+            let source_id = SourceId::crates_io(config)?;
             let mut source = RegistrySource::remote(source_id, &HashSet::new(), config);
 
             debug!("source id loaded: {:?}", source_id);

src/changes.rs

@@ -1182,7 +1182,7 @@ impl<'a> Serialize for RPathChanges<'a> {
         let mut seq = serializer.serialize_seq(Some(self.1.len()))?;
 
         for e in &self.1 {
-            seq.serialize_element(&RPathChange(self.0, &e))?;
+            seq.serialize_element(&RPathChange(self.0, e))?;
         }
 
         seq.end()

src/mismatch.rs

@@ -198,7 +198,12 @@ impl<'a, 'tcx> TypeRelation<'tcx> for MismatchRelation<'a, 'tcx> {
                 None
             }
             (&TyKind::RawPtr(a_mt), &TyKind::RawPtr(b_mt)) => {
-                let _ = ty::relate::relate_type_and_mut(self, a_mt, b_mt, ty::VarianceDiagMutKind::RawPtr)?;
+                let _ = ty::relate::relate_type_and_mut(
+                    self,
+                    a_mt,
+                    b_mt,
+                    ty::VarianceDiagMutKind::RawPtr,
+                )?;
                 None
             }
             (&TyKind::Ref(a_r, a_ty, _), &TyKind::Ref(b_r, b_ty, _)) => {

src/translate.rs

@@ -311,7 +311,7 @@ impl<'a, 'tcx> TranslationContext<'a, 'tcx> {
                                 debug!("translating type param: {:?}", param);
                                 let type_param = self.id_mapping.get_type_param(&target_def_id);
                                 debug!("translated type param: {:?}", type_param);
-                                match self.tcx.mk_param_from_def(&type_param).unpack() {
+                                match self.tcx.mk_param_from_def(type_param).unpack() {
                                     GenericArgKind::Type(param_t) => param_t,
                                     _ => unreachable!(),
                                 }
@@ -366,7 +366,7 @@ impl<'a, 'tcx> TranslationContext<'a, 'tcx> {
 
     /// Translate an item's type.
     pub fn translate_item_type(&self, orig_def_id: DefId, orig: Ty<'tcx>) -> Ty<'tcx> {
-        self.translate(&self.construct_index_map(orig_def_id), &orig)
+        self.translate(&self.construct_index_map(orig_def_id), orig)
     }
 
     /// Translate a predicate using a type parameter index map.
@@ -420,7 +420,7 @@ impl<'a, 'tcx> TranslationContext<'a, 'tcx> {
                                 substs: target_substs,
                                 item_def_id: target_def_id,
                             },
-                            ty: self.translate(index_map, &pred.ty),
+                            ty: self.translate(index_map, pred.ty),
                         }
                     } else {
                         return None;
@@ -434,7 +434,7 @@ impl<'a, 'tcx> TranslationContext<'a, 'tcx> {
                 }
                 PredicateKind::ClosureKind(did, substs, kind) => PredicateKind::ClosureKind(
                     self.translate_orig(did),
-                    self.translate(index_map, &substs),
+                    self.translate(index_map, substs),
                     kind,
                 ),
                 PredicateKind::Subtype(pred) => PredicateKind::Subtype({
@@ -459,8 +459,8 @@ impl<'a, 'tcx> TranslationContext<'a, 'tcx> {
                     }
                 }
                 PredicateKind::ConstEquate(c1, c2) => PredicateKind::ConstEquate(
-                    self.translate(index_map, &c1),
-                    self.translate(index_map, &c2),
+                    self.translate(index_map, c1),
+                    self.translate(index_map, c2),
                 ),
                 // NOTE: Only used for Chalk trait solver
                 PredicateKind::TypeWellFormedFromEnv(_) => unimplemented!(),
@@ -513,7 +513,7 @@ impl<'a, 'tcx> TranslationContext<'a, 'tcx> {
         let index_map = self.construct_index_map(orig_def_id);
         TraitRef {
             def_id: self.translate_orig(orig_trait_ref.def_id),
-            substs: self.translate(&index_map, &orig_trait_ref.substs),
+            substs: self.translate(&index_map, orig_trait_ref.substs),
         }
     }