Cargo fmt

Author: af-afk

benches/arraystring.rs

@@ -1,6 +1,6 @@
-
 extern crate arrayvec;
-#[macro_use] extern crate bencher;
+#[macro_use]
+extern crate bencher;
 
 use arrayvec::ArrayString;
 
@@ -10,8 +10,7 @@ fn try_push_c(b: &mut Bencher) {
     let mut v = ArrayString::<512>::new();
     b.iter(|| {
         v.clear();
-        while v.try_push('c').is_ok() {
-        }
+        while v.try_push('c').is_ok() {}
         v.len()
     });
     b.bytes = v.capacity() as u64;
@@ -21,8 +20,7 @@ fn try_push_alpha(b: &mut Bencher) {
     let mut v = ArrayString::<512>::new();
     b.iter(|| {
         v.clear();
-        while v.try_push('α').is_ok() {
-        }
+        while v.try_push('α').is_ok() {}
         v.len()
     });
     b.bytes = v.capacity() as u64;
@@ -85,6 +83,13 @@ fn push_string(b: &mut Bencher) {
     b.bytes = v.capacity() as u64;
 }
 
-benchmark_group!(benches, try_push_c, try_push_alpha, try_push_string, push_c,
-                 push_alpha, push_string);
+benchmark_group!(
+    benches,
+    try_push_c,
+    try_push_alpha,
+    try_push_string,
+    push_c,
+    push_alpha,
+    push_string
+);
 benchmark_main!(benches);

benches/extend.rs

@@ -1,13 +1,13 @@
-
 extern crate arrayvec;
-#[macro_use] extern crate bencher;
+#[macro_use]
+extern crate bencher;
 
 use std::io::Write;
 
 use arrayvec::ArrayVec;
 
-use bencher::Bencher;
 use bencher::black_box;
+use bencher::Bencher;
 
 fn extend_with_constant(b: &mut Bencher) {
     let mut v = ArrayVec::<u8, 512>::new();
@@ -67,12 +67,13 @@ fn extend_from_slice(b: &mut Bencher) {
     b.bytes = v.capacity() as u64;
 }
 
-benchmark_group!(benches,
-                 extend_with_constant,
-                 extend_with_range,
-                 extend_with_slice,
-                 extend_with_write,
-                 extend_from_slice
+benchmark_group!(
+    benches,
+    extend_with_constant,
+    extend_with_range,
+    extend_with_slice,
+    extend_with_write,
+    extend_from_slice
 );
 
 benchmark_main!(benches);

src/array_string.rs

@@ -25,7 +25,7 @@ use serde::{Deserialize, Deserializer, Serialize, Serializer};
 extern crate alloc;
 
 #[cfg(all(not(feature = "std"), feature = "borsh"))]
-use alloc::{string::ToString, format};
+use alloc::{format, string::ToString};
 
 /// A string with a fixed capacity.
 ///

src/arrayvec_impl.rs

@@ -16,17 +16,13 @@ pub(crate) trait ArrayVecImpl {
     /// Return a slice containing all elements of the vector.
     fn as_slice(&self) -> &[Self::Item] {
         let len = self.len();
-        unsafe {
-            slice::from_raw_parts(self.as_ptr(), len)
-        }
+        unsafe { slice::from_raw_parts(self.as_ptr(), len) }
     }
 
     /// Return a mutable slice containing all elements of the vector.
     fn as_mut_slice(&mut self) -> &mut [Self::Item] {
         let len = self.len();
-        unsafe {
-            std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
-        }
+        unsafe { std::slice::from_raw_parts_mut(self.as_mut_ptr(), len) }
     }
 
     /// Return a raw pointer to the vector's buffer.
@@ -84,4 +80,3 @@ pub(crate) trait ArrayVecImpl {
         }
     }
 }
-

src/char.rs

@@ -11,13 +11,13 @@
 // Original authors: alexchrichton, bluss
 
 // UTF-8 ranges and tags for encoding characters
-const TAG_CONT: u8    = 0b1000_0000;
-const TAG_TWO_B: u8   = 0b1100_0000;
+const TAG_CONT: u8 = 0b1000_0000;
+const TAG_TWO_B: u8 = 0b1100_0000;
 const TAG_THREE_B: u8 = 0b1110_0000;
-const TAG_FOUR_B: u8  = 0b1111_0000;
-const MAX_ONE_B: u32   =     0x80;
-const MAX_TWO_B: u32   =    0x800;
-const MAX_THREE_B: u32 =  0x10000;
+const TAG_FOUR_B: u8 = 0b1111_0000;
+const MAX_ONE_B: u32 = 0x80;
+const MAX_TWO_B: u32 = 0x800;
+const MAX_THREE_B: u32 = 0x10000;
 
 /// Placeholder
 pub struct EncodeUtf8Error;
@@ -29,8 +29,7 @@ pub struct EncodeUtf8Error;
 ///
 /// Safety: `ptr` must be writable for `len` bytes.
 #[inline]
-pub unsafe fn encode_utf8(ch: char, ptr: *mut u8, len: usize) -> Result<usize, EncodeUtf8Error>
-{
+pub unsafe fn encode_utf8(ch: char, ptr: *mut u8, len: usize) -> Result<usize, EncodeUtf8Error> {
     let code = ch as u32;
     if code < MAX_ONE_B && len >= 1 {
         ptr.add(0).write(code as u8);
@@ -41,28 +40,29 @@ pub unsafe fn encode_utf8(ch: char, ptr: *mut u8, len: usize) -> Result<usize, E
         return Ok(2);
     } else if code < MAX_THREE_B && len >= 3 {
         ptr.add(0).write((code >> 12 & 0x0F) as u8 | TAG_THREE_B);
-        ptr.add(1).write((code >>  6 & 0x3F) as u8 | TAG_CONT);
+        ptr.add(1).write((code >> 6 & 0x3F) as u8 | TAG_CONT);
         ptr.add(2).write((code & 0x3F) as u8 | TAG_CONT);
         return Ok(3);
     } else if len >= 4 {
         ptr.add(0).write((code >> 18 & 0x07) as u8 | TAG_FOUR_B);
         ptr.add(1).write((code >> 12 & 0x3F) as u8 | TAG_CONT);
-        ptr.add(2).write((code >>  6 & 0x3F) as u8 | TAG_CONT);
+        ptr.add(2).write((code >> 6 & 0x3F) as u8 | TAG_CONT);
         ptr.add(3).write((code & 0x3F) as u8 | TAG_CONT);
         return Ok(4);
     };
     Err(EncodeUtf8Error)
 }
 
-
 #[test]
 #[cfg_attr(miri, ignore)] // Miri is too slow
 fn test_encode_utf8() {
     // Test that all codepoints are encoded correctly
     let mut data = [0u8; 16];
     for codepoint in 0..=(std::char::MAX as u32) {
         if let Some(ch) = std::char::from_u32(codepoint) {
-            for elt in &mut data { *elt = 0; }
+            for elt in &mut data {
+                *elt = 0;
+            }
             let ptr = data.as_mut_ptr();
             let len = data.len();
             unsafe {
@@ -89,4 +89,3 @@ fn test_encode_utf8_oob() {
         }
     }
 }
-

src/errors.rs

@@ -1,8 +1,8 @@
-use std::fmt;
-#[cfg(feature="std")]
+#[cfg(feature = "std")]
 use std::any::Any;
-#[cfg(feature="std")]
+#[cfg(feature = "std")]
 use std::error::Error;
+use std::fmt;
 
 /// Error value indicating insufficient capacity
 #[derive(Clone, Copy, Eq, Ord, PartialEq, PartialOrd)]
@@ -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: element }
     }
 
     /// Extract the overflowing element
@@ -31,7 +29,7 @@ impl<T> CapacityError<T> {
 
 const CAPERROR: &'static str = "insufficient capacity";
 
-#[cfg(feature="std")]
+#[cfg(feature = "std")]
 /// Requires `features="std"`.
 impl<T: Any> Error for CapacityError<T> {}
 
@@ -46,4 +44,3 @@ impl<T> fmt::Debug for CapacityError<T> {
         write!(f, "{}: {}", "CapacityError", CAPERROR)
     }
 }
-

src/lib.rs

@@ -19,14 +19,13 @@
 //!
 //! This version of arrayvec requires Rust 1.51 or later.
 //!
-#![doc(html_root_url="https://docs.rs/arrayvec/0.7/")]
-
+#![doc(html_root_url = "https://docs.rs/arrayvec/0.7/")]
 #![cfg_attr(not(feature = "std"), no_std)]
 
-#[cfg(feature="serde")]
+#[cfg(feature = "serde")]
 extern crate serde;
 
-#[cfg(not(feature="std"))]
+#[cfg(not(feature = "std"))]
 extern crate core as std;
 
 #[cfg(not(target_pointer_width = "16"))]
@@ -45,7 +44,7 @@ macro_rules! assert_capacity_limit {
                 panic!("ArrayVec: largest supported capacity is u16::MAX");
             }
         }
-    }
+    };
 }
 
 macro_rules! assert_capacity_limit_const {
@@ -58,14 +57,14 @@ macro_rules! assert_capacity_limit_const {
     }
 }
 
-mod arrayvec_impl;
-mod arrayvec;
 mod array_string;
+mod arrayvec;
+mod arrayvec_impl;
 mod char;
 mod errors;
 mod utils;
 
 pub use crate::array_string::ArrayString;
 pub use crate::errors::CapacityError;
 
-pub use crate::arrayvec::{ArrayVec, IntoIter, Drain};
+pub use crate::arrayvec::{ArrayVec, Drain, IntoIter};

src/utils.rs

@@ -8,4 +8,3 @@ impl<T, const N: usize> MakeMaybeUninit<T, N> {
 
     pub(crate) const ARRAY: [MaybeUninit<T>; N] = [Self::VALUE; N];
 }
-

tests/borsh.rs

@@ -9,16 +9,18 @@ fn assert_ser<T: borsh::BorshSerialize>(v: &T, expected_bytes: &[u8]) {
     assert_eq!(actual_bytes, expected_bytes);
 }
 
-fn assert_roundtrip<T: borsh::BorshSerialize + borsh::BorshDeserialize + PartialEq + fmt::Debug>(v: &T) {
+fn assert_roundtrip<T: borsh::BorshSerialize + borsh::BorshDeserialize + PartialEq + fmt::Debug>(
+    v: &T,
+) {
     let mut bytes = Vec::new();
     v.serialize(&mut bytes).unwrap();
     let v_de = T::try_from_slice(&bytes).unwrap();
     assert_eq!(*v, v_de);
 }
 
 mod array_vec {
+    use super::{assert_roundtrip, assert_ser};
     use arrayvec::ArrayVec;
-    use super::{assert_ser, assert_roundtrip};
 
     #[test]
     fn test_empty() {
@@ -47,8 +49,8 @@ mod array_vec {
 }
 
 mod array_string {
+    use super::{assert_roundtrip, assert_ser};
     use arrayvec::ArrayString;
-    use super::{assert_ser, assert_roundtrip};
 
     #[test]
     fn test_empty() {