From 0622e38fd495f6719cedf95aea1e21fbcce2f60f Mon Sep 17 00:00:00 2001
From: Matthieu Pizenberg <matthieu.pizenberg@gmail.com>
Date: Sat, 7 Aug 2021 15:21:01 +0200
Subject: [PATCH] refactor: make clippy happy

---
 src/internal/incompatibility.rs  |  4 +--
 src/internal/partial_solution.rs |  2 +-
 src/solver.rs                    | 59 ++++++++++++++++----------------
 src/term.rs                      |  2 +-
 4 files changed, 33 insertions(+), 34 deletions(-)

diff --git a/src/internal/incompatibility.rs b/src/internal/incompatibility.rs
index acf900b8..b1d44d5f 100644
--- a/src/internal/incompatibility.rs
+++ b/src/internal/incompatibility.rs
@@ -152,7 +152,7 @@ impl<P: Package, V: Version> Incompatibility<P, V> {
             false
         } else {
             let (package, term) = self.package_terms.iter().next().unwrap();
-            (package == root_package) && term.contains(&root_version)
+            (package == root_package) && term.contains(root_version)
         }
     }
 
@@ -220,7 +220,7 @@ impl<'a, P: Package, V: Version + 'a> Incompatibility<P, V> {
     pub fn relation(&self, terms: impl Fn(&P) -> Option<&'a Term<V>>) -> Relation<P> {
         let mut relation = Relation::Satisfied;
         for (package, incompat_term) in self.package_terms.iter() {
-            match terms(package).map(|term| incompat_term.relation_with(&term)) {
+            match terms(package).map(|term| incompat_term.relation_with(term)) {
                 Some(term::Relation::Satisfied) => {}
                 Some(term::Relation::Contradicted) => {
                     return Relation::Contradicted(package.clone());
diff --git a/src/internal/partial_solution.rs b/src/internal/partial_solution.rs
index 84bfc5f8..6d6a7ca3 100644
--- a/src/internal/partial_solution.rs
+++ b/src/internal/partial_solution.rs
@@ -223,7 +223,7 @@ impl<P: Package, V: Version> PartialSolution<P, V> {
                     pa.dated_derivations
                         .iter()
                         .fold(Term::any(), |acc, dated_derivation| {
-                            let term = store[dated_derivation.cause].get(&p).unwrap().negate();
+                            let term = store[dated_derivation.cause].get(p).unwrap().negate();
                             acc.intersection(&term)
                         }),
                 );
diff --git a/src/solver.rs b/src/solver.rs
index 62015911..40366bb6 100644
--- a/src/solver.rs
+++ b/src/solver.rs
@@ -137,38 +137,37 @@ pub fn resolve<P: Package, V: Version>(
         {
             // Retrieve that package dependencies.
             let p = &next;
-            let dependencies =
-                match dependency_provider
-                    .get_dependencies(&p, &v)
-                    .map_err(|err| PubGrubError::ErrorRetrievingDependencies {
-                        package: p.clone(),
-                        version: v.clone(),
-                        source: err,
-                    })? {
-                    Dependencies::Unknown => {
-                        state.add_incompatibility(Incompatibility::unavailable_dependencies(
-                            p.clone(),
-                            v.clone(),
-                        ));
-                        continue;
+            let dependencies = match dependency_provider.get_dependencies(p, &v).map_err(|err| {
+                PubGrubError::ErrorRetrievingDependencies {
+                    package: p.clone(),
+                    version: v.clone(),
+                    source: err,
+                }
+            })? {
+                Dependencies::Unknown => {
+                    state.add_incompatibility(Incompatibility::unavailable_dependencies(
+                        p.clone(),
+                        v.clone(),
+                    ));
+                    continue;
+                }
+                Dependencies::Known(x) => {
+                    if x.contains_key(p) {
+                        return Err(PubGrubError::SelfDependency {
+                            package: p.clone(),
+                            version: v.clone(),
+                        });
                     }
-                    Dependencies::Known(x) => {
-                        if x.contains_key(&p) {
-                            return Err(PubGrubError::SelfDependency {
-                                package: p.clone(),
-                                version: v.clone(),
-                            });
-                        }
-                        if let Some((dependent, _)) = x.iter().find(|(_, r)| r == &&Range::none()) {
-                            return Err(PubGrubError::DependencyOnTheEmptySet {
-                                package: p.clone(),
-                                version: v.clone(),
-                                dependent: dependent.clone(),
-                            });
-                        }
-                        x
+                    if let Some((dependent, _)) = x.iter().find(|(_, r)| r == &&Range::none()) {
+                        return Err(PubGrubError::DependencyOnTheEmptySet {
+                            package: p.clone(),
+                            version: v.clone(),
+                            dependent: dependent.clone(),
+                        });
                     }
-                };
+                    x
+                }
+            };
 
             // Add that package and version if the dependencies are not problematic.
             let dep_incompats =
diff --git a/src/term.rs b/src/term.rs
index bc038acf..ad8158fd 100644
--- a/src/term.rs
+++ b/src/term.rs
@@ -162,7 +162,7 @@ impl<'a, V: 'a + Version> Term<V> {
 
 impl<V: Version> AsRef<Term<V>> for Term<V> {
     fn as_ref(&self) -> &Term<V> {
-        &self
+        self
     }
 }