Fix clippy issues

Author: Wodann

src/string.rs

@@ -451,7 +451,7 @@ impl String {
     #[inline]
     #[must_use]
     pub fn with_capacity(capacity: usize) -> Self {
-        Self::with_capacity_in(capacity, Global)
+        Self::with_capacity_in(capacity, &Global)
     }
 
     /// Decode a UTF-16 encoded vector `v` into a `String`, returning [`Err`]
@@ -475,7 +475,7 @@ impl String {
     /// assert!(String::from_utf16(v).is_err());
     /// ```
     pub fn from_utf16(v: &[u16]) -> Result<Self, FromUtf16Error> {
-        Self::from_utf16_in(v, Global)
+        Self::from_utf16_in(v, &Global)
     }
 
     /// Decode a UTF-16 encoded slice `v` into a `String`, replacing
@@ -578,7 +578,7 @@ impl<A: DeallocRef> String<A> {
     /// # Panics
     /// Panics if the allocation fails.
     #[inline]
-    pub fn with_capacity_in(capacity: usize, a: A) -> Self
+    pub fn with_capacity_in(capacity: usize, a: &A) -> Self
     where
         A: AllocRef,
     {
@@ -589,12 +589,12 @@ impl<A: DeallocRef> String<A> {
 
     /// Like `with_capacity_in` but returns errors instead of panicking.
     #[inline]
-    pub fn try_with_capacity_in(capacity: usize, a: A) -> Result<Self, CollectionAllocErr<A>>
+    pub fn try_with_capacity_in(capacity: usize, a: &A) -> Result<Self, CollectionAllocErr<A>>
     where
         A: AllocRef,
     {
         Ok(Self {
-            vec: Vec::try_with_capacity_in(capacity, &a)?,
+            vec: Vec::try_with_capacity_in(capacity, a)?,
         })
     }
 
@@ -603,7 +603,7 @@ impl<A: DeallocRef> String<A> {
     /// # Panics
     /// Panics if the allocation fails.
     #[inline]
-    pub fn from_str_in(s: &str, a: A) -> Self
+    pub fn from_str_in(s: &str, a: &A) -> Self
     where
         A: ReallocRef,
     {
@@ -614,7 +614,7 @@ impl<A: DeallocRef> String<A> {
 
     /// Like `from_str_in` but returns errors instead of panicking.
     #[inline]
-    pub fn try_from_str_in(s: &str, a: A) -> Result<Self, CollectionAllocErr<A>>
+    pub fn try_from_str_in(s: &str, a: &A) -> Result<Self, CollectionAllocErr<A>>
     where
         A: ReallocRef,
     {
@@ -703,7 +703,7 @@ impl<A: DeallocRef> String<A> {
     /// # Panics
     ///
     /// Panics if allocation fails.
-    pub fn from_utf8_lossy_in(v: &[u8], a: A) -> Self
+    pub fn from_utf8_lossy_in(v: &[u8], a: &A) -> Self
     where
         A: ReallocRef,
     {
@@ -715,7 +715,7 @@ impl<A: DeallocRef> String<A> {
     }
 
     /// Like `from_utf8_lossy_in` but returns errors instead of panicking.
-    pub fn try_from_utf8_lossy_in(v: &[u8], a: A) -> Result<Self, CollectionAllocErr<A>>
+    pub fn try_from_utf8_lossy_in(v: &[u8], a: &A) -> Result<Self, CollectionAllocErr<A>>
     where
         A: ReallocRef,
     {
@@ -751,7 +751,7 @@ impl<A: DeallocRef> String<A> {
     }
 
     /// Like `from_utf16` but parameterized over the choice of allocator for the returned `String`.
-    pub fn from_utf16_in(v: &[u16], a: A) -> Result<Self, FromUtf16Error>
+    pub fn from_utf16_in(v: &[u16], a: &A) -> Result<Self, FromUtf16Error>
     where
         A: ReallocRef,
     {

src/vec.rs

@@ -401,7 +401,7 @@ impl<T> Vec<T> {
     #[inline]
     #[must_use]
     pub fn with_capacity(capacity: usize) -> Self {
-        Self::with_capacity_in(capacity, Global)
+        Self::with_capacity_in(capacity, &Global)
     }
 
     /// Creates a `Vec<T>` directly from the raw components of another vector.
@@ -488,12 +488,12 @@ impl<T, A: DeallocRef> Vec<T, A> {
     /// * if the requested capacity exceeds `usize::MAX` bytes.
     /// * on 32-bit platforms if the requested capacity exceeds `isize::MAX` bytes.
     #[inline]
-    pub fn with_capacity_in(capacity: usize, a: A) -> Self
+    pub fn with_capacity_in(capacity: usize, a: &A) -> Self
     where
         A: AllocRef,
     {
         Self {
-            buf: RawVec::with_capacity_in(capacity, &a),
+            buf: RawVec::with_capacity_in(capacity, a),
             len: 0,
         }
     }
@@ -2024,11 +2024,11 @@ impl<T: PartialEq, A: DeallocRef> Vec<T, A> {
 
 #[doc(hidden)]
 pub fn from_elem<T: Clone>(elem: T, n: usize) -> Vec<T> {
-    from_elem_in(elem, n, Global)
+    from_elem_in(elem, n, &Global)
 }
 
 #[doc(hidden)]
-pub fn from_elem_in<T: Clone, A>(elem: T, n: usize, a: A) -> Vec<T, A>
+pub fn from_elem_in<T: Clone, A>(elem: T, n: usize, a: &A) -> Vec<T, A>
 where
     A: ReallocRef,
 {
@@ -2043,23 +2043,24 @@ where
 pub fn try_from_elem_in<T: Clone, A: ReallocRef>(
     elem: T,
     n: usize,
-    a: A,
+    a: &A,
 ) -> Result<Vec<T, A>, CollectionAllocErr<A>> {
     <T as SpecFromElem<A>>::try_from_elem_in(elem, n, a)
 }
 
 // Specialization trait used for Vec::from_elem
 trait SpecFromElem<A: AllocRef>: Sized {
-    fn try_from_elem_in(elem: Self, n: usize, a: A) -> Result<Vec<Self, A>, CollectionAllocErr<A>>;
+    fn try_from_elem_in(elem: Self, n: usize, a: &A)
+    -> Result<Vec<Self, A>, CollectionAllocErr<A>>;
 }
 
 impl<T: Clone, A: ReallocRef> SpecFromElem<A> for T {
     default fn try_from_elem_in(
         elem: Self,
         n: usize,
-        a: A,
+        a: &A,
     ) -> Result<Vec<Self, A>, CollectionAllocErr<A>> {
-        let mut v = Vec::try_with_capacity_in(n, &a)?;
+        let mut v = Vec::try_with_capacity_in(n, a)?;
         v.try_extend_with(n, ExtendElement(elem))?;
         Ok(v)
     }
@@ -2068,15 +2069,19 @@ impl<T: Clone, A: ReallocRef> SpecFromElem<A> for T {
 #[allow(clippy::use_self)]
 impl<A: ReallocRef> SpecFromElem<A> for u8 {
     #[inline]
-    fn try_from_elem_in(elem: Self, n: usize, a: A) -> Result<Vec<Self, A>, CollectionAllocErr<A>> {
+    fn try_from_elem_in(
+        elem: Self,
+        n: usize,
+        a: &A,
+    ) -> Result<Vec<Self, A>, CollectionAllocErr<A>> {
         if elem == 0 {
             return Ok(Vec {
-                buf: RawVec::try_with_capacity_zeroed_in(n, &a)?,
+                buf: RawVec::try_with_capacity_zeroed_in(n, a)?,
                 len: n,
             });
         }
         unsafe {
-            let mut v = Vec::try_with_capacity_in(n, &a)?;
+            let mut v = Vec::try_with_capacity_in(n, a)?;
             ptr::write_bytes(v.as_mut_ptr(), elem, n);
             v.set_len(n);
             Ok(v)
@@ -2086,14 +2091,18 @@ impl<A: ReallocRef> SpecFromElem<A> for u8 {
 
 impl<T: Clone + IsZero, A: ReallocRef> SpecFromElem<A> for T {
     #[inline]
-    fn try_from_elem_in(elem: Self, n: usize, a: A) -> Result<Vec<Self, A>, CollectionAllocErr<A>> {
+    fn try_from_elem_in(
+        elem: Self,
+        n: usize,
+        a: &A,
+    ) -> Result<Vec<Self, A>, CollectionAllocErr<A>> {
         if elem.is_zero() {
             return Ok(Vec {
-                buf: RawVec::try_with_capacity_zeroed_in(n, &a)?,
+                buf: RawVec::try_with_capacity_zeroed_in(n, a)?,
                 len: n,
             });
         }
-        let mut v = Vec::try_with_capacity_in(n, &a)?;
+        let mut v = Vec::try_with_capacity_in(n, a)?;
         v.try_extend_with(n, ExtendElement(elem))?;
         Ok(v)
     }
@@ -2201,7 +2210,7 @@ impl<T: Clone, A: AllocRef, B: AllocRef> CloneIn<B> for Vec<T, A> {
     type Cloned = Vec<T, B>;
 
     fn clone_in(&self, a: B) -> Self::Cloned {
-        let mut v = Vec::with_capacity_in(self.len(), a);
+        let mut v = Vec::with_capacity_in(self.len(), &a);
 
         self.iter()
             .cloned()