Fix clippy lints

benches/arraystring.rs

@@ -35,7 +35,7 @@ fn try_push_string(b: &mut Bencher) {
     b.iter(|| {
         v.clear();
         for ch in input.chars().cycle() {
-            if !v.try_push(ch).is_ok() {
+            if v.try_push(ch).is_err() {
                 break;
             }
         }

benches/extend.rs

@@ -38,7 +38,7 @@ fn extend_with_slice(b: &mut Bencher) {
     let data = [1; 512];
     b.iter(|| {
         v.clear();
-        let iter = data.iter().map(|&x| x);
+        let iter = data.iter().copied();
         v.extend(iter);
         v[511]
     });
@@ -50,7 +50,7 @@ fn extend_with_write(b: &mut Bencher) {
     let data = [1; 512];
     b.iter(|| {
         v.clear();
-        v.write(&data[..]).ok();
+        v.write_all(&data[..]).ok();
         v[511]
     });
     b.bytes = v.capacity() as u64;

src/array_string.rs

@@ -309,7 +309,7 @@ impl<const CAP: usize> ArrayString<CAP>
     /// assert_eq!(s.pop(), None);
     /// ```
     pub fn pop(&mut self) -> Option<char> {
-        let ch = match self.chars().rev().next() {
+        let ch = match self.chars().next_back() {
             Some(ch) => ch,
             None => return None,
         };
@@ -394,8 +394,8 @@ impl<const CAP: usize> ArrayString<CAP>
 
     /// Set the strings’s length.
     ///
-    /// This function is `unsafe` because it changes the notion of the
-    /// number of “valid” bytes in the string. Use with care.
+    /// # Safety
+    /// The data must be initialised up to the length provided.
     ///
     /// This method uses *debug assertions* to check the validity of `length`
     /// and may use other debug assertions.
@@ -523,17 +523,12 @@ impl<const CAP: usize> Clone for ArrayString<CAP>
     fn clone(&self) -> ArrayString<CAP> {
         *self
     }
-    fn clone_from(&mut self, rhs: &Self) {
-        // guaranteed to fit due to types matching.
-        self.clear();
-        self.try_push_str(rhs).ok();
-    }
 }
 
 impl<const CAP: usize> PartialOrd for ArrayString<CAP>
 {
     fn partial_cmp(&self, rhs: &Self) -> Option<cmp::Ordering> {
-        (**self).partial_cmp(&**rhs)
+        Some(self.cmp(rhs))
     }
     fn lt(&self, rhs: &Self) -> bool { **self < **rhs }
     fn le(&self, rhs: &Self) -> bool { **self <= **rhs }
@@ -677,7 +672,7 @@ impl<'a, const CAP: usize> TryFrom<fmt::Arguments<'a>> for ArrayString<CAP>
     fn try_from(f: fmt::Arguments<'a>) -> Result<Self, Self::Error> {
         use fmt::Write;
         let mut v = Self::new();
-        v.write_fmt(f).map_err(|e| CapacityError::new(e))?;
+        v.write_fmt(f).map_err(CapacityError::new)?;
         Ok(v)
     }
 }

src/arrayvec.rs

@@ -208,11 +208,15 @@ impl<T, const CAP: usize> ArrayVec<T, CAP> {
 
     /// Push `element` to the end of the vector without checking the capacity.
     ///
+    /// # Safety
+    ///
     /// It is up to the caller to ensure the capacity of the vector is
     /// sufficiently large.
     ///
     /// This method uses *debug assertions* to check that the arrayvec is not full.
     ///
+    /// # Example
+    ///
     /// ```
     /// use arrayvec::ArrayVec;
     ///
@@ -537,8 +541,8 @@ impl<T, const CAP: usize> ArrayVec<T, CAP> {
 
     /// Set the vector’s length without dropping or moving out elements
     ///
-    /// This method is `unsafe` because it changes the notion of the
-    /// number of “valid” elements in the vector. Use with care.
+    /// # Safety
+    /// The data must be initialised up to the length provided.
     ///
     /// This method uses *debug assertions* to check that `length` is
     /// not greater than the capacity.
@@ -664,13 +668,14 @@ impl<T, const CAP: usize> ArrayVec<T, CAP> {
 
     /// Return the inner fixed size array.
     ///
-    /// Safety:
-    /// This operation is safe if and only if length equals capacity.
+    /// # Safety
+    ///
+    /// [`Self::len`] must equal [`Self::capacity`].
     pub unsafe fn into_inner_unchecked(self) -> [T; CAP] {
         debug_assert_eq!(self.len(), self.capacity());
+
         let self_ = ManuallyDrop::new(self);
-        let array = ptr::read(self_.as_ptr() as *const [T; CAP]);
-        array
+        ptr::read(self_.as_ptr() as *const [T; CAP])
     }
 
     /// Returns the ArrayVec, replacing the original with a new empty ArrayVec.
@@ -1013,7 +1018,7 @@ impl<'a, T: 'a, const CAP: usize> Drop for Drain<'a, T, CAP> {
         // len is currently 0 so panicking while dropping will not cause a double drop.
 
         // exhaust self first
-        while let Some(_) = self.next() { }
+        for _ in self.by_ref() { }
 
         if self.tail_len > 0 {
             unsafe {

src/errors.rs

@@ -13,9 +13,7 @@ pub struct CapacityError<T = ()> {
 impl<T> CapacityError<T> {
     /// Create a new `CapacityError` from `element`.
     pub const fn new(element: T) -> CapacityError<T> {
-        CapacityError {
-            element: element,
-        }
+        CapacityError { element }
     }
 
     /// Extract the overflowing element
@@ -29,21 +27,19 @@ impl<T> CapacityError<T> {
     }
 }
 
-const CAPERROR: &'static str = "insufficient capacity";
-
 #[cfg(feature="std")]
 /// Requires `features="std"`.
 impl<T: Any> Error for CapacityError<T> {}
 
 impl<T> fmt::Display for CapacityError<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", CAPERROR)
+        f.write_str("insufficient capacity")
     }
 }
 
 impl<T> fmt::Debug for CapacityError<T> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}: {}", "CapacityError", CAPERROR)
+        write!(f, "CapacityError: {}", self)
     }
 }
 

tests/tests.rs

@@ -300,9 +300,10 @@ fn test_extend_capacity_panic_2() {
 
 #[test]
 fn test_is_send_sync() {
-    let data = ArrayVec::<Vec<i32>,  5>::new();
-    &data as &dyn Send;
-    &data as &dyn Sync;
+    fn assert_send_and_sync<T: Send + Sync>(_: T) {}
+
+    let data = ArrayVec::<Vec<i32>, 5>::new();
+    assert_send_and_sync(data)
 }
 
 #[test]
@@ -594,7 +595,7 @@ fn test_string_push() {
     let text = "abcαβγ";
     let mut s = ArrayString::<8>::new();
     for c in text.chars() {
-        if let Err(_) = s.try_push(c) {
+        if s.try_push(c).is_err() {
             break;
         }
     }