Fix more clippy warnings

micwoj92 · whitequark · commit 3b1bc437d0ae · 2023-12-10T09:37:02.000Z
diff --git a/src/map.rs b/src/map.rs
@@ -48,9 +48,9 @@ impl<'a, K: 'a, V: 'a> fmt::Debug for ManagedMap<'a, K, V>
         where K: fmt::Debug, V: fmt::Debug {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            &ManagedMap::Borrowed(ref x) => write!(f, "Borrowed({:?})", x),
+            ManagedMap::Borrowed(x) => write!(f, "Borrowed({:?})", x),
             #[cfg(any(feature = "std", feature = "alloc"))]
-            &ManagedMap::Owned(ref x)    => write!(f, "Owned({:?})", x)
+            ManagedMap::Owned(x)    => write!(f, "Owned({:?})", x)
         }
     }
 }
@@ -84,9 +84,9 @@ impl<T> From<Option<T>> for RevOption<T> {
     }
 }
 
-impl<T> Into<Option<T>> for RevOption<T> {
-    fn into(self) -> Option<T> {
-        match self {
+impl<T> From<RevOption<T>> for Option<T> {
+    fn from(val: RevOption<T>) -> Self {
+        match val {
             RevOption::Some(x) => Some(x),
             RevOption::None => None
         }
@@ -234,7 +234,7 @@ fn binary_search_by_key<K, V, Q>(slice: &[Option<(K, V)>], key: &Q) -> Result<us
     where K: Ord + Borrow<Q>, Q: Ord + ?Sized
 {
     slice.binary_search_by_key(&RevOption::Some(key), |entry| {
-        entry.as_ref().map(|&(ref key, _)| key.borrow()).into()
+        entry.as_ref().map(|(key, _)| key.borrow()).into()
     })
 }
 
@@ -269,14 +269,14 @@ impl<'a, K: Ord + 'a, V: 'a> ManagedMap<'a, K, V> {
         where K: Borrow<Q>, Q: Ord + ?Sized
     {
         match self {
-            &ManagedMap::Borrowed(ref pairs) => {
+            ManagedMap::Borrowed(pairs) => {
                 match pair_by_key(pairs, key.borrow()) {
-                    Ok(&(_, ref value)) => Some(value),
+                    Ok((_, value)) => Some(value),
                     Err(_) => None
                 }
             },
             #[cfg(any(feature = "std", feature = "alloc"))]
-            &ManagedMap::Owned(ref map) => map.get(key)
+            ManagedMap::Owned(map) => map.get(key)
         }
     }
 
@@ -299,7 +299,7 @@ impl<'a, K: Ord + 'a, V: 'a> ManagedMap<'a, K, V> {
             where K: Borrow<Q>, Q: Ord + ?Sized, R: RangeBounds<Q>, 'b: 'a
     {
         match self {
-            &ManagedMap::Borrowed(ref pairs) => {
+            ManagedMap::Borrowed(pairs) => {
                 match binary_search_by_key_range(&pairs[0..self.len()], range) {
                     Ok((begin, end)) => Range(RangeInner::Borrowed {
                         slice: &pairs[begin..end], begin: 0, end: end-begin }),
@@ -308,7 +308,7 @@ impl<'a, K: Ord + 'a, V: 'a> ManagedMap<'a, K, V> {
                 }
             },
             #[cfg(any(feature = "std", feature = "alloc"))]
-            &ManagedMap::Owned(ref map) => {
+            ManagedMap::Owned(map) => {
                 Range(RangeInner::Owned(map.range(range)))
             },
         }
@@ -364,33 +364,33 @@ impl<'a, K: Ord + 'a, V: 'a> ManagedMap<'a, K, V> {
     /// ManagedMap contains no elements?
     pub fn is_empty(&self) -> bool {
         match self {
-            &ManagedMap::Borrowed(ref pairs) =>
+            ManagedMap::Borrowed(pairs) =>
                 pairs.iter().all(|item| item.is_none()),
             #[cfg(any(feature = "std", feature = "alloc"))]
-            &ManagedMap::Owned(ref map) =>
+            ManagedMap::Owned(map) =>
                 map.is_empty()
         }
     }
 
     /// Returns the number of elements in the ManagedMap.
     pub fn len(&self) -> usize {
         match self {
-            &ManagedMap::Borrowed(ref pairs) =>
+            ManagedMap::Borrowed(pairs) =>
                 pairs.iter()
                 .take_while(|item| item.is_some())
                 .count(),
             #[cfg(any(feature = "std", feature = "alloc"))]
-            &ManagedMap::Owned(ref map) =>
+            ManagedMap::Owned(map) =>
                 map.len()
         }
     }
 
     pub fn iter(&self) -> Iter<K, V> {
         match self {
-            &ManagedMap::Borrowed(ref pairs) =>
+            ManagedMap::Borrowed(pairs) =>
                 Iter::Borrowed(pairs.iter()),
             #[cfg(any(feature = "std", feature = "alloc"))]
-            &ManagedMap::Owned(ref map) =>
+            ManagedMap::Owned(map) =>
                 Iter::Owned(map.iter()),
         }
     }
@@ -433,14 +433,14 @@ impl<'a, K: Ord + 'a, V: 'a> Iterator for Iter<'a, K, V> {
 
     fn size_hint(&self) -> (usize, Option<usize>) {
         match self {
-            &Iter::Borrowed(ref iter) => {
+            Iter::Borrowed(iter) => {
                 let len = iter.clone()
                     .take_while(|item| item.is_some())
                     .count();
                 (len, Some(len))
             },
             #[cfg(any(feature = "std", feature = "alloc"))]
-            &Iter::Owned(ref iter) =>
+            Iter::Owned(iter) =>
                 iter.size_hint(),
         }
     }
@@ -473,12 +473,12 @@ impl<'a, K: Ord + 'a, V: 'a> Iterator for IterMut<'a, K, V> {
 
     fn size_hint(&self) -> (usize, Option<usize>) {
         match self {
-            &IterMut::Borrowed(ref iter) => {
+            IterMut::Borrowed(iter) => {
                 let (_, upper) = iter.size_hint();
                 (0, upper)
             },
             #[cfg(any(feature = "std", feature = "alloc"))]
-            &IterMut::Owned(ref iter) =>
+            IterMut::Owned(iter) =>
                 iter.size_hint(),
         }
     }
@@ -504,7 +504,7 @@ mod test {
 
     fn unwrap<'a, K, V>(map: &'a ManagedMap<'a, K, V>) -> &'a [Option<(K, V)>] {
         match map {
-            &ManagedMap::Borrowed(ref map) => map,
+            ManagedMap::Borrowed(map) => map,
             _ => unreachable!()
         }
     }
diff --git a/src/object.rs b/src/object.rs
@@ -40,9 +40,9 @@ impl<'a, T: 'a + ?Sized> fmt::Debug for Managed<'a, T>
         where T: fmt::Debug {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            &Managed::Borrowed(ref x) => write!(f, "Borrowed({:?})", x),
+            Managed::Borrowed(x) => write!(f, "Borrowed({:?})", x),
             #[cfg(any(feature = "std", feature = "alloc"))]
-            &Managed::Owned(ref x)    => write!(f, "Owned({:?})", x)
+            Managed::Owned(x)    => write!(f, "Owned({:?})", x)
         }
     }
 }
@@ -72,9 +72,9 @@ impl<'a, T: 'a + ?Sized> Deref for Managed<'a, T> {
 
     fn deref(&self) -> &Self::Target {
         match self {
-            &Managed::Borrowed(ref value) => value,
+            Managed::Borrowed(value) => value,
             #[cfg(any(feature = "std", feature = "alloc"))]
-            &Managed::Owned(ref value) => value
+            Managed::Owned(value) => value
         }
     }
 }
diff --git a/src/slice.rs b/src/slice.rs
@@ -38,9 +38,9 @@ impl<'a, T: 'a> fmt::Debug for ManagedSlice<'a, T>
         where T: fmt::Debug {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            &ManagedSlice::Borrowed(ref x) => write!(f, "Borrowed({:?})", x),
+            ManagedSlice::Borrowed(x) => write!(f, "Borrowed({:?})", x),
             #[cfg(any(feature = "std", feature = "alloc"))]
-            &ManagedSlice::Owned(ref x)    => write!(f, "Owned({:?})", x)
+            ManagedSlice::Owned(x)    => write!(f, "Owned({:?})", x)
         }
     }
 }
@@ -82,9 +82,9 @@ impl<'a, T: 'a> Deref for ManagedSlice<'a, T> {
 
     fn deref(&self) -> &Self::Target {
         match self {
-            &ManagedSlice::Borrowed(ref value) => value,
+            ManagedSlice::Borrowed(value) => value,
             #[cfg(any(feature = "std", feature = "alloc"))]
-            &ManagedSlice::Owned(ref value) => value
+            ManagedSlice::Owned(value) => value
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -48,9 +48,9 @@ impl<'a, K: 'a, V: 'a> fmt::Debug for ManagedMap<'a, K, V>`
`48`	`48`	`where K: fmt::Debug, V: fmt::Debug {`
`49`	`49`	`fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`50`	`50`	`match self {`
`51`		`- &ManagedMap::Borrowed(ref x) => write!(f, "Borrowed({:?})", x),`
	`51`	`+ ManagedMap::Borrowed(x) => write!(f, "Borrowed({:?})", x),`
`52`	`52`	`#[cfg(any(feature = "std", feature = "alloc"))]`
`53`		`- &ManagedMap::Owned(ref x) => write!(f, "Owned({:?})", x)`
	`53`	`+ ManagedMap::Owned(x) => write!(f, "Owned({:?})", x)`
`54`	`54`	`}`
`55`	`55`	`}`
`56`	`56`	`}`
`@@ -84,9 +84,9 @@ impl<T> From<Option<T>> for RevOption<T> {`
`84`	`84`	`}`
`85`	`85`	`}`
`86`	`86`
`87`		`-impl<T> Into<Option<T>> for RevOption<T> {`
`88`		`- fn into(self) -> Option<T> {`
`89`		`- match self {`
	`87`	`+impl<T> From<RevOption<T>> for Option<T> {`
	`88`	`+ fn from(val: RevOption<T>) -> Self {`
	`89`	`+ match val {`
`90`	`90`	`RevOption::Some(x) => Some(x),`
`91`	`91`	`RevOption::None => None`
`92`	`92`	`}`
`@@ -234,7 +234,7 @@ fn binary_search_by_key<K, V, Q>(slice: &[Option<(K, V)>], key: &Q) -> Result<us`
`234`	`234`	`where K: Ord + Borrow<Q>, Q: Ord + ?Sized`
`235`	`235`	`{`
`236`	`236`	`slice.binary_search_by_key(&RevOption::Some(key), \|entry\| {`
`237`		`- entry.as_ref().map(\|&(ref key, _)\| key.borrow()).into()`
	`237`	`+ entry.as_ref().map(\|(key, _)\| key.borrow()).into()`
`238`	`238`	`})`
`239`	`239`	`}`
`240`	`240`
`@@ -269,14 +269,14 @@ impl<'a, K: Ord + 'a, V: 'a> ManagedMap<'a, K, V> {`
`269`	`269`	`where K: Borrow<Q>, Q: Ord + ?Sized`
`270`	`270`	`{`
`271`	`271`	`match self {`
`272`		`- &ManagedMap::Borrowed(ref pairs) => {`
	`272`	`+ ManagedMap::Borrowed(pairs) => {`
`273`	`273`	`match pair_by_key(pairs, key.borrow()) {`
`274`		`- Ok(&(_, ref value)) => Some(value),`
	`274`	`+ Ok((_, value)) => Some(value),`
`275`	`275`	`Err(_) => None`
`276`	`276`	`}`
`277`	`277`	`},`
`278`	`278`	`#[cfg(any(feature = "std", feature = "alloc"))]`
`279`		`- &ManagedMap::Owned(ref map) => map.get(key)`
	`279`	`+ ManagedMap::Owned(map) => map.get(key)`
`280`	`280`	`}`
`281`	`281`	`}`
`282`	`282`
`@@ -299,7 +299,7 @@ impl<'a, K: Ord + 'a, V: 'a> ManagedMap<'a, K, V> {`
`299`	`299`	`where K: Borrow<Q>, Q: Ord + ?Sized, R: RangeBounds<Q>, 'b: 'a`
`300`	`300`	`{`
`301`	`301`	`match self {`
`302`		`- &ManagedMap::Borrowed(ref pairs) => {`
	`302`	`+ ManagedMap::Borrowed(pairs) => {`
`303`	`303`	`match binary_search_by_key_range(&pairs[0..self.len()], range) {`
`304`	`304`	`Ok((begin, end)) => Range(RangeInner::Borrowed {`
`305`	`305`	`slice: &pairs[begin..end], begin: 0, end: end-begin }),`
`@@ -308,7 +308,7 @@ impl<'a, K: Ord + 'a, V: 'a> ManagedMap<'a, K, V> {`
`308`	`308`	`}`
`309`	`309`	`},`
`310`	`310`	`#[cfg(any(feature = "std", feature = "alloc"))]`
`311`		`- &ManagedMap::Owned(ref map) => {`
	`311`	`+ ManagedMap::Owned(map) => {`
`312`	`312`	`Range(RangeInner::Owned(map.range(range)))`
`313`	`313`	`},`
`314`	`314`	`}`
`@@ -364,33 +364,33 @@ impl<'a, K: Ord + 'a, V: 'a> ManagedMap<'a, K, V> {`
`364`	`364`	`/// ManagedMap contains no elements?`
`365`	`365`	`pub fn is_empty(&self) -> bool {`
`366`	`366`	`match self {`
`367`		`- &ManagedMap::Borrowed(ref pairs) =>`
	`367`	`+ ManagedMap::Borrowed(pairs) =>`
`368`	`368`	`pairs.iter().all(\|item\| item.is_none()),`
`369`	`369`	`#[cfg(any(feature = "std", feature = "alloc"))]`
`370`		`- &ManagedMap::Owned(ref map) =>`
	`370`	`+ ManagedMap::Owned(map) =>`
`371`	`371`	`map.is_empty()`
`372`	`372`	`}`
`373`	`373`	`}`
`374`	`374`
`375`	`375`	`/// Returns the number of elements in the ManagedMap.`
`376`	`376`	`pub fn len(&self) -> usize {`
`377`	`377`	`match self {`
`378`		`- &ManagedMap::Borrowed(ref pairs) =>`
	`378`	`+ ManagedMap::Borrowed(pairs) =>`
`379`	`379`	`pairs.iter()`
`380`	`380`	`.take_while(\|item\| item.is_some())`
`381`	`381`	`.count(),`
`382`	`382`	`#[cfg(any(feature = "std", feature = "alloc"))]`
`383`		`- &ManagedMap::Owned(ref map) =>`
	`383`	`+ ManagedMap::Owned(map) =>`
`384`	`384`	`map.len()`
`385`	`385`	`}`
`386`	`386`	`}`
`387`	`387`
`388`	`388`	`pub fn iter(&self) -> Iter<K, V> {`
`389`	`389`	`match self {`
`390`		`- &ManagedMap::Borrowed(ref pairs) =>`
	`390`	`+ ManagedMap::Borrowed(pairs) =>`
`391`	`391`	`Iter::Borrowed(pairs.iter()),`
`392`	`392`	`#[cfg(any(feature = "std", feature = "alloc"))]`
`393`		`- &ManagedMap::Owned(ref map) =>`
	`393`	`+ ManagedMap::Owned(map) =>`
`394`	`394`	`Iter::Owned(map.iter()),`
`395`	`395`	`}`
`396`	`396`	`}`
`@@ -433,14 +433,14 @@ impl<'a, K: Ord + 'a, V: 'a> Iterator for Iter<'a, K, V> {`
`433`	`433`
`434`	`434`	`fn size_hint(&self) -> (usize, Option<usize>) {`
`435`	`435`	`match self {`
`436`		`- &Iter::Borrowed(ref iter) => {`
	`436`	`+ Iter::Borrowed(iter) => {`
`437`	`437`	`let len = iter.clone()`
`438`	`438`	`.take_while(\|item\| item.is_some())`
`439`	`439`	`.count();`
`440`	`440`	`(len, Some(len))`
`441`	`441`	`},`
`442`	`442`	`#[cfg(any(feature = "std", feature = "alloc"))]`
`443`		`- &Iter::Owned(ref iter) =>`
	`443`	`+ Iter::Owned(iter) =>`
`444`	`444`	`iter.size_hint(),`
`445`	`445`	`}`
`446`	`446`	`}`
`@@ -473,12 +473,12 @@ impl<'a, K: Ord + 'a, V: 'a> Iterator for IterMut<'a, K, V> {`
`473`	`473`
`474`	`474`	`fn size_hint(&self) -> (usize, Option<usize>) {`
`475`	`475`	`match self {`
`476`		`- &IterMut::Borrowed(ref iter) => {`
	`476`	`+ IterMut::Borrowed(iter) => {`
`477`	`477`	`let (_, upper) = iter.size_hint();`
`478`	`478`	`(0, upper)`
`479`	`479`	`},`
`480`	`480`	`#[cfg(any(feature = "std", feature = "alloc"))]`
`481`		`- &IterMut::Owned(ref iter) =>`
	`481`	`+ IterMut::Owned(iter) =>`
`482`	`482`	`iter.size_hint(),`
`483`	`483`	`}`
`484`	`484`	`}`
`@@ -504,7 +504,7 @@ mod test {`
`504`	`504`
`505`	`505`	`fn unwrap<'a, K, V>(map: &'a ManagedMap<'a, K, V>) -> &'a [Option<(K, V)>] {`
`506`	`506`	`match map {`
`507`		`- &ManagedMap::Borrowed(ref map) => map,`
	`507`	`+ ManagedMap::Borrowed(map) => map,`
`508`	`508`	`_ => unreachable!()`
`509`	`509`	`}`
`510`	`510`	`}`
Original file line number	Diff line number	Diff line change
`@@ -40,9 +40,9 @@ impl<'a, T: 'a + ?Sized> fmt::Debug for Managed<'a, T>`
`40`	`40`	`where T: fmt::Debug {`
`41`	`41`	`fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`42`	`42`	`match self {`
`43`		`- &Managed::Borrowed(ref x) => write!(f, "Borrowed({:?})", x),`
	`43`	`+ Managed::Borrowed(x) => write!(f, "Borrowed({:?})", x),`
`44`	`44`	`#[cfg(any(feature = "std", feature = "alloc"))]`
`45`		`- &Managed::Owned(ref x) => write!(f, "Owned({:?})", x)`
	`45`	`+ Managed::Owned(x) => write!(f, "Owned({:?})", x)`
`46`	`46`	`}`
`47`	`47`	`}`
`48`	`48`	`}`
`@@ -72,9 +72,9 @@ impl<'a, T: 'a + ?Sized> Deref for Managed<'a, T> {`
`72`	`72`
`73`	`73`	`fn deref(&self) -> &Self::Target {`
`74`	`74`	`match self {`
`75`		`- &Managed::Borrowed(ref value) => value,`
	`75`	`+ Managed::Borrowed(value) => value,`
`76`	`76`	`#[cfg(any(feature = "std", feature = "alloc"))]`
`77`		`- &Managed::Owned(ref value) => value`
	`77`	`+ Managed::Owned(value) => value`
`78`	`78`	`}`
`79`	`79`	`}`
`80`	`80`	`}`
Original file line number	Diff line number	Diff line change
`@@ -38,9 +38,9 @@ impl<'a, T: 'a> fmt::Debug for ManagedSlice<'a, T>`
`38`	`38`	`where T: fmt::Debug {`
`39`	`39`	`fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {`
`40`	`40`	`match self {`
`41`		`- &ManagedSlice::Borrowed(ref x) => write!(f, "Borrowed({:?})", x),`
	`41`	`+ ManagedSlice::Borrowed(x) => write!(f, "Borrowed({:?})", x),`
`42`	`42`	`#[cfg(any(feature = "std", feature = "alloc"))]`
`43`		`- &ManagedSlice::Owned(ref x) => write!(f, "Owned({:?})", x)`
	`43`	`+ ManagedSlice::Owned(x) => write!(f, "Owned({:?})", x)`
`44`	`44`	`}`
`45`	`45`	`}`
`46`	`46`	`}`
`@@ -82,9 +82,9 @@ impl<'a, T: 'a> Deref for ManagedSlice<'a, T> {`
`82`	`82`
`83`	`83`	`fn deref(&self) -> &Self::Target {`
`84`	`84`	`match self {`
`85`		`- &ManagedSlice::Borrowed(ref value) => value,`
	`85`	`+ ManagedSlice::Borrowed(value) => value,`
`86`	`86`	`#[cfg(any(feature = "std", feature = "alloc"))]`
`87`		`- &ManagedSlice::Owned(ref value) => value`
	`87`	`+ ManagedSlice::Owned(value) => value`
`88`	`88`	`}`
`89`	`89`	`}`
`90`	`90`	`}`