Clippy for rust 1.54

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());

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)
                         }),
                 );

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 =

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
     }
 }