diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index 79edf65f..f8b543d2 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -31,6 +31,11 @@ jobs: uses: dtolnay/rust-toolchain@master with: toolchain: ${{ matrix.toolchain }} + components: rustfmt + + - name: Style check + if: matrix.toolchain == 'nightly' + run: cargo fmt --all --check - name: Cargo build run: cargo build --verbose diff --git a/Cargo.lock b/Cargo.lock index 15853d3f..c6d327a4 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -8,24 +8,12 @@ version = "1.12.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "fc652a48c352aef3ea3aed32080501cf3ef6ed5da78602a020c991775b0aff04" -[[package]] -name = "itoa" -version = "1.0.18" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" - [[package]] name = "malloc_size_of" version = "0.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e5d719de8b8f230028cf8192ae4c1b25267cd6b8a99d2747d345a70b8c81aa13" -[[package]] -name = "memchr" -version = "2.8.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cf8baf1c55e62ffcace7a9f06f4bd9cd3f0c4beb022d3b367256b91b87513d98" - [[package]] name = "proc-macro2" version = "1.0.107" @@ -74,16 +62,12 @@ dependencies = [ ] [[package]] -name = "serde_json" -version = "1.0.151" +name = "serde_test" +version = "1.0.177" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c841b55ecdae098c80dcae9cf767f6f8a0c2cdb3416bbef72181df4d0fe73f14" +checksum = "7f901ee573cab6b3060453d2d5f0bae4e6d628c23c0a962ff9b5f1d7c8d4f1ed" dependencies = [ - "itoa", - "memchr", "serde", - "serde_core", - "zmij", ] [[package]] @@ -93,7 +77,7 @@ dependencies = [ "bytes", "malloc_size_of", "serde_core", - "serde_json", + "serde_test", ] [[package]] @@ -112,9 +96,3 @@ name = "unicode-ident" version = "1.0.24" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75" - -[[package]] -name = "zmij" -version = "1.0.23" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "29666d0abbfad1e3dc4dcf6144730dd3a3ab225bbbdac83319345b1b44ccfc1b" diff --git a/Cargo.toml b/Cargo.toml index 44184f1d..19391ffb 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -26,7 +26,7 @@ serde_core = { version = "1.0.221", optional = true, default-features = false } malloc_size_of = { version = "0.1.1", optional = true, default-features = false } [dev-dependencies] -serde_json = "1.0" +serde_test = "1.0" [package.metadata.docs.rs] all-features = true diff --git a/src/lib.rs b/src/lib.rs index 6ddc848e..f7b1bba1 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -195,13 +195,13 @@ impl RawSmallVec { // SAFETY: it is safe because we aren't reading the value, just getting a // reference to it. reading it would be UB potentially, but for that downstream // unsafe is required - (unsafe {&raw const self.inline}) as *mut T + (unsafe { &raw const self.inline }) as *mut T } #[inline] const fn as_mut_ptr_inline(&mut self) -> *mut T { // SAFETY: same as above - (unsafe {&raw mut self.inline}) as *mut T + (unsafe { &raw mut self.inline }) as *mut T } /// # Safety @@ -292,7 +292,7 @@ impl Clone for TaggedLen { fn clone(&self) -> Self { Self(self.0, PhantomData) } - + #[inline] fn clone_from(&mut self, source: &Self) { self.0 = source.0; @@ -493,7 +493,10 @@ impl Drain<'_, T, N> { let range_start = vec.len(); let range_end = self.tail_start; let range_slice = unsafe { - core::slice::from_raw_parts_mut(vec.as_mut_ptr().add(range_start), range_end - range_start) + core::slice::from_raw_parts_mut( + vec.as_mut_ptr().add(range_start), + range_end - range_start, + ) }; for place in range_slice { @@ -689,7 +692,11 @@ impl Drop for Splice<'_, I, N> { } // Collect any remaining elements. - let mut collected = self.replace_with.by_ref().collect::>().into_iter(); + let mut collected = self + .replace_with + .by_ref() + .collect::>() + .into_iter(); // Now we have an exact count. if collected.len() > 0 { self.drain.move_tail(collected.len()); @@ -725,7 +732,6 @@ unsafe impl Send for IntoIter where T: Send {} unsafe impl Sync for IntoIter where T: Sync {} impl IntoIter { - #[inline] const fn as_ptr(&self) -> *const T { let on_heap = self.end.on_heap(); @@ -754,10 +760,7 @@ impl IntoIter { // So the pointer arithmetic is valid, and so is the construction of the slice unsafe { let ptr = self.as_ptr(); - core::slice::from_raw_parts( - ptr.add(self.begin), - self.end.value() - self.begin, - ) + core::slice::from_raw_parts(ptr.add(self.begin), self.end.value() - self.begin) } } @@ -766,10 +769,7 @@ impl IntoIter { // SAFETY: see above unsafe { let ptr = self.as_mut_ptr(); - core::slice::from_raw_parts_mut( - ptr.add(self.begin), - self.end.value() - self.begin, - ) + core::slice::from_raw_parts_mut(ptr.add(self.begin), self.end.value() - self.begin) } } } @@ -842,7 +842,9 @@ impl SmallVec { #[inline] pub const fn from_buf(elements: [T; S]) -> Self { - const { assert!(S <= N); } + const { + assert!(S <= N); + } // Although we create a new buffer, since S and N are known at compile time, // even with `-C opt-level=1`, it gets optimized as best as it could be. (Checked with ) @@ -1198,7 +1200,10 @@ impl SmallVec { R: core::ops::RangeBounds, I: IntoIterator, { - Splice { drain: self.drain(range), replace_with: replace_with.into_iter() } + Splice { + drain: self.drain(range), + replace_with: replace_with.into_iter(), + } } #[inline] @@ -1233,7 +1238,11 @@ impl SmallVec { #[inline] pub fn pop_if(&mut self, predicate: impl FnOnce(&mut T) -> bool) -> Option { let last = self.last_mut()?; - if predicate(last) { self.pop() } else { None } + if predicate(last) { + self.pop() + } else { + None + } } #[inline] @@ -1398,7 +1407,10 @@ impl SmallVec { self.set_inline(); alloc::alloc::dealloc( ptr.cast().as_ptr(), - Layout::from_size_align_unchecked(capacity * size_of::(), align_of::()), + Layout::from_size_align_unchecked( + capacity * size_of::(), + align_of::(), + ), ); } } else if target < self.capacity() { @@ -1429,7 +1441,10 @@ impl SmallVec { #[inline] pub fn swap_remove(&mut self, index: usize) -> T { let len = self.len(); - assert!(index < len, "swap_remove index (is {index}) should be < len (is {len})"); + assert!( + index < len, + "swap_remove index (is {index}) should be < len (is {len})" + ); // This can't overflow since `len > index >= 0` let new_len = len - 1; unsafe { @@ -1461,7 +1476,10 @@ impl SmallVec { #[inline] pub fn remove(&mut self, index: usize) -> T { let len = self.len(); - assert!(index < len, "removal index (is {index}) should be < len (is {len})"); + assert!( + index < len, + "removal index (is {index}) should be < len (is {len})" + ); let new_len = len - 1; unsafe { // SAFETY: new_len < len @@ -1478,7 +1496,10 @@ impl SmallVec { #[inline] pub fn insert(&mut self, index: usize, value: T) { let len = self.len(); - assert!(index <= len, "insertion index (is {index}) should be <= len (is {len})"); + assert!( + index <= len, + "insertion index (is {index}) should be <= len (is {len})" + ); self.reserve(1); let ptr = self.as_mut_ptr(); unsafe { @@ -1674,7 +1695,9 @@ impl SmallVec { pub fn leak<'a>(self) -> &'a mut [T] { if !self.spilled() { - panic!("SmallVec::leak() called on inline (stack) SmallVec, which cannot be safely leaked"); + panic!( + "SmallVec::leak() called on inline (stack) SmallVec, which cannot be safely leaked" + ); } let mut me = ManuallyDrop::new(self); unsafe { core::slice::from_raw_parts_mut(me.as_mut_ptr(), me.len()) } @@ -1807,12 +1830,11 @@ impl SmallVec { #[inline] pub fn extend_from_slice_copy(&mut self, other: &[T]) where - T: Copy + T: Copy, { - let len = other.len(); let src = other.as_ptr(); - + let l = self.len(); self.reserve(len); @@ -1828,7 +1850,7 @@ impl SmallVec { pub fn extend_from_within_copy(&mut self, src: R) where R: core::ops::RangeBounds, - T: Copy + T: Copy, { let src = slice_range(src, ..self.len()); let core::ops::Range { start, end } = src; @@ -1847,7 +1869,7 @@ impl SmallVec { pub fn insert_from_slice_copy(&mut self, index: usize, other: &[T]) where - T: Copy + T: Copy, { let l = self.len(); let len = other.len(); @@ -1871,7 +1893,7 @@ impl SmallVec { /// for types with the [`Copy`] trait. pub fn from_slice_copy(slice: &[T]) -> Self where - T: Copy + T: Copy, { let src = slice.as_ptr(); let len = slice.len(); diff --git a/src/tests.rs b/src/tests.rs index bdbea33a..cfd801b4 100644 --- a/src/tests.rs +++ b/src/tests.rs @@ -538,7 +538,7 @@ fn test_from() { let vec = vec![]; let small_vec: SmallVec = SmallVec::from(vec); - assert_eq!(&*small_vec, &[0u8; 0]); + assert_eq!(&*small_vec, &[0u8; 0]); drop(small_vec); let vec = vec![1, 2, 3, 4, 5]; @@ -587,10 +587,7 @@ fn test_from() { #[test] fn test_from_slice() { assert_eq!(&SmallVec::::from(&[1][..])[..], [1]); - assert_eq!( - &SmallVec::::from(&[1, 2, 3][..])[..], - [1, 2, 3] - ); + assert_eq!(&SmallVec::::from(&[1, 2, 3][..])[..], [1, 2, 3]); } #[test] @@ -801,27 +798,26 @@ fn test_write() { #[cfg(feature = "serde")] #[test] fn test_serde() { - use serde_core::{Serialize, Deserialize}; - use serde_json::{Serializer, Deserializer}; - let mut bytes = Vec::::new(); - let mut serializer = Serializer::new(&mut bytes); + use serde_test::{assert_tokens, Token}; let mut small_vec: SmallVec = SmallVec::new(); + assert_tokens(&small_vec, &[Token::Seq { len: Some(0) }, Token::SeqEnd]); small_vec.push(1); - let _ = small_vec.serialize(&mut serializer); - let mut deserializer = Deserializer::from_slice(bytes.as_slice()); - let decoded: SmallVec = SmallVec::deserialize(&mut deserializer).unwrap(); - assert_eq!(small_vec, decoded); - // Spill the vec - small_vec.push(2); - small_vec.push(3); - small_vec.push(4); - // Check again after spilling. - let mut bytes = Vec::::new(); - let mut serializer = Serializer::new(&mut bytes); - let _ = small_vec.serialize(&mut serializer); - let mut deserializer = Deserializer::from_slice(bytes.as_slice()); - let decoded: SmallVec = SmallVec::deserialize(&mut deserializer).unwrap(); - assert_eq!(small_vec, decoded); + assert_tokens( + &small_vec, + &[Token::Seq { len: Some(1) }, Token::I32(1), Token::SeqEnd], + ); + small_vec.extend([2, 3, 4]); + assert_tokens( + &small_vec, + &[ + Token::Seq { len: Some(4) }, + Token::I32(1), + Token::I32(2), + Token::I32(3), + Token::I32(4), + Token::SeqEnd, + ], + ); } #[test]