Upgrade rust/crates/smallvec to 1.4.1
Change-Id: Ic29f1d940bed8ce943818e91ee71e61b69a2caf3
diff --git a/.cargo_vcs_info.json b/.cargo_vcs_info.json
index d6c458a..51909b5 100644
--- a/.cargo_vcs_info.json
+++ b/.cargo_vcs_info.json
@@ -1,5 +1,5 @@
{
"git": {
- "sha1": "78c252868b73851addaef9ead0c3aacaee6892e4"
+ "sha1": "5513f4716bad73823a29f2484a359158fce576be"
}
}
diff --git a/Cargo.toml b/Cargo.toml
index a316331..d5c8b5c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,7 +13,7 @@
[package]
edition = "2018"
name = "smallvec"
-version = "1.4.0"
+version = "1.4.1"
authors = ["Simon Sapin <simon.sapin@exyr.org>"]
description = "'Small vector' optimization: store up to a small number of items on the stack"
documentation = "https://docs.rs/smallvec/"
@@ -29,6 +29,7 @@
[dependencies.serde]
version = "1"
optional = true
+default-features = false
[dev-dependencies.bincode]
version = "1.0.1"
diff --git a/Cargo.toml.orig b/Cargo.toml.orig
index 0e8f13a..65d995a 100644
--- a/Cargo.toml.orig
+++ b/Cargo.toml.orig
@@ -1,6 +1,6 @@
[package]
name = "smallvec"
-version = "1.4.0"
+version = "1.4.1"
edition = "2018"
authors = ["Simon Sapin <simon.sapin@exyr.org>"]
license = "MIT/Apache-2.0"
@@ -23,7 +23,7 @@
path = "lib.rs"
[dependencies]
-serde = { version = "1", optional = true }
+serde = { version = "1", optional = true, default-features = false }
[dev_dependencies]
bincode = "1.0.1"
diff --git a/METADATA b/METADATA
index 7c7eccd..6be0c08 100644
--- a/METADATA
+++ b/METADATA
@@ -1,8 +1,5 @@
name: "smallvec"
-description:
- "'Small vector' optimization: store up to a small number of items on the "
- "stack"
-
+description: "\'Small vector\' optimization: store up to a small number of items on the stack"
third_party {
url {
type: HOMEPAGE
@@ -12,7 +9,11 @@
type: GIT
value: "https://github.com/servo/rust-smallvec"
}
- version: "1.4.0"
- last_upgrade_date { year: 2020 month: 6 day: 11 }
+ version: "1.4.1"
license_type: NOTICE
+ last_upgrade_date {
+ year: 2020
+ month: 7
+ day: 30
+ }
}
diff --git a/benches/bench.rs b/benches/bench.rs
index 36cb133..7a3c07e 100644
--- a/benches/bench.rs
+++ b/benches/bench.rs
@@ -1,4 +1,5 @@
#![feature(test)]
+#![allow(deprecated)]
#[macro_use]
extern crate smallvec;
diff --git a/lib.rs b/lib.rs
index caea125..3dbc901 100644
--- a/lib.rs
+++ b/lib.rs
@@ -16,6 +16,11 @@
//!
//! ## Optional features
//!
+//! ### `serde`
+//!
+//! When this optional dependency is enabled, `SmallVec` implements the `serde::Serialize` and
+//! `serde::Deserialize` traits.
+//!
//! ### `write`
//!
//! When this feature is enabled, `SmallVec<[u8; _]>` implements the `std::io::Write` trait.
@@ -34,6 +39,8 @@
//! To use this feature add `features = ["union"]` in the `smallvec` section of Cargo.toml.
//! Note that this feature requires a nightly compiler (for now).
//!
+//! Tracking issue: [rust-lang/rust#55149](https://github.com/rust-lang/rust/issues/55149)
+//!
//! ### `const_generics`
//!
//! **This feature is unstable and requires a nightly build of the Rust toolchain.**
@@ -41,6 +48,8 @@
//! When this feature is enabled, `SmallVec` works with any arrays of any size, not just a fixed
//! list of sizes.
//!
+//! Tracking issue: [rust-lang/rust#44580](https://github.com/rust-lang/rust/issues/44580)
+//!
//! ### `specialization`
//!
//! **This feature is unstable and requires a nightly build of the Rust toolchain.**
@@ -49,6 +58,8 @@
//! of `Copy` types. (Without this feature, you can use `SmallVec::from_slice` to get optimal
//! performance for `Copy` types.)
//!
+//! Tracking issue: [rust-lang/rust#31844](https://github.com/rust-lang/rust/issues/31844)
+//!
//! ### `may_dangle`
//!
//! **This feature is unstable and requires a nightly build of the Rust toolchain.**
@@ -56,6 +67,8 @@
//! This feature makes the Rust compiler less strict about use of vectors that contain borrowed
//! references. For details, see the
//! [Rustonomicon](https://doc.rust-lang.org/1.42.0/nomicon/dropck.html#an-escape-hatch).
+//!
+//! Tracking issue: [rust-lang/rust#34761](https://github.com/rust-lang/rust/issues/34761)
#![no_std]
#![cfg_attr(feature = "union", feature(untagged_unions))]
@@ -145,7 +158,8 @@
$crate::SmallVec::from_elem($elem, $n)
});
($($x:expr),*$(,)*) => ({
- let count = 0usize $(+ smallvec!(@one $x))*;
+ let count = 0usize $(+ $crate::smallvec!(@one $x))*;
+ #[allow(unused_mut)]
let mut vec = $crate::SmallVec::new();
if count <= vec.inline_size() {
$(vec.push($x);)*
@@ -190,11 +204,14 @@
/// initialize(&mut small_vec);
/// assert_eq!(&small_vec as &[_], b"Test!");
/// ```
+#[doc(hidden)]
+#[deprecated]
pub trait ExtendFromSlice<T> {
/// Extends a collection from a slice of its element type
fn extend_from_slice(&mut self, other: &[T]);
}
+#[allow(deprecated)]
impl<T: Clone> ExtendFromSlice<T> for Vec<T> {
fn extend_from_slice(&mut self, other: &[T]) {
Vec::extend_from_slice(self, other)
@@ -230,11 +247,11 @@
/// FIXME: use `Layout::array` when we require a Rust version where it’s stable
/// https://github.com/rust-lang/rust/issues/55724
fn layout_array<T>(n: usize) -> Result<Layout, CollectionAllocErr> {
- let size = mem::size_of::<T>().checked_mul(n)
+ let size = mem::size_of::<T>()
+ .checked_mul(n)
.ok_or(CollectionAllocErr::CapacityOverflow)?;
let align = mem::align_of::<T>();
- Layout::from_size_align(size, align)
- .map_err(|_| CollectionAllocErr::CapacityOverflow)
+ Layout::from_size_align(size, align).map_err(|_| CollectionAllocErr::CapacityOverflow)
}
unsafe fn deallocate<T>(ptr: *mut T, capacity: usize) {
@@ -445,8 +462,8 @@
/// ```
pub struct SmallVec<A: Array> {
// The capacity field is used to determine which of the storage variants is active:
- // If capacity <= A::size() then the inline variant is used and capacity holds the current length of the vector (number of elements actually in use).
- // If capacity > A::size() then the heap variant is used and capacity holds the size of the memory allocation.
+ // If capacity <= Self::inline_capacity() then the inline variant is used and capacity holds the current length of the vector (number of elements actually in use).
+ // If capacity > Self::inline_capacity() then the heap variant is used and capacity holds the size of the memory allocation.
capacity: usize,
data: SmallVecData<A>,
}
@@ -489,7 +506,7 @@
/// Construct a new `SmallVec` from a `Vec<A::Item>`.
///
- /// Elements will be copied to the inline buffer if vec.capacity() <= A::size().
+ /// Elements will be copied to the inline buffer if vec.capacity() <= Self::inline_capacity().
///
/// ```rust
/// use smallvec::SmallVec;
@@ -501,7 +518,7 @@
/// ```
#[inline]
pub fn from_vec(mut vec: Vec<A::Item>) -> SmallVec<A> {
- if vec.capacity() <= A::size() {
+ if vec.capacity() <= Self::inline_capacity() {
unsafe {
let mut data = SmallVecData::<A>::from_inline(MaybeUninit::uninit());
let len = vec.len();
@@ -596,8 +613,28 @@
/// The maximum number of elements this vector can hold inline
#[inline]
+ fn inline_capacity() -> usize {
+ if mem::size_of::<A::Item>() > 0 {
+ A::size()
+ } else {
+ // For zero-size items code like `ptr.add(offset)` always returns the same pointer.
+ // Therefore all items are at the same address,
+ // and any array size has capacity for infinitely many items.
+ // The capacity is limited by the bit width of the length field.
+ //
+ // `Vec` also does this:
+ // https://github.com/rust-lang/rust/blob/1.44.0/src/liballoc/raw_vec.rs#L186
+ //
+ // In our case, this also ensures that a smallvec of zero-size items never spills,
+ // and we never try to allocate zero bytes which `std::alloc::alloc` disallows.
+ core::usize::MAX
+ }
+ }
+
+ /// The maximum number of elements this vector can hold inline
+ #[inline]
pub fn inline_size(&self) -> usize {
- A::size()
+ Self::inline_capacity()
}
/// The number of elements stored in the vector
@@ -627,7 +664,7 @@
let (ptr, len) = self.data.heap();
(ptr, len, self.capacity)
} else {
- (self.data.inline(), self.capacity, A::size())
+ (self.data.inline(), self.capacity, Self::inline_capacity())
}
}
}
@@ -640,7 +677,7 @@
let &mut (ptr, ref mut len_ptr) = self.data.heap_mut();
(ptr, len_ptr, self.capacity)
} else {
- (self.data.inline_mut(), &mut self.capacity, A::size())
+ (self.data.inline_mut(), &mut self.capacity, Self::inline_capacity())
}
}
}
@@ -648,7 +685,7 @@
/// Returns `true` if the data has spilled into a separate heap-allocated buffer.
#[inline]
pub fn spilled(&self) -> bool {
- self.capacity > A::size()
+ self.capacity > Self::inline_capacity()
}
/// Creates a draining iterator that removes the specified range in the vector
@@ -753,6 +790,7 @@
deallocate(ptr, cap);
} else if new_cap != cap {
let layout = layout_array::<A::Item>(new_cap)?;
+ debug_assert!(layout.size() > 0);
let new_alloc;
if unspilled {
new_alloc = NonNull::new(alloc::alloc::alloc(layout))
@@ -1012,7 +1050,7 @@
/// This method returns `Err(Self)` if the SmallVec is too short (and the `A` contains uninitialized elements),
/// or if the SmallVec is too long (and all the elements were spilled to the heap).
pub fn into_inner(self) -> Result<A, Self> {
- if self.spilled() || self.len() != A::size() {
+ if self.spilled() || self.len() != A::size() { // Note: A::size, not Self::inline_capacity
Err(self)
} else {
unsafe {
@@ -1090,6 +1128,48 @@
self.dedup_by(|a, b| key(a) == key(b));
}
+ /// Resizes the `SmallVec` in-place so that `len` is equal to `new_len`.
+ ///
+ /// If `new_len` is greater than `len`, the `SmallVec` is extended by the difference, with each
+ /// additional slot filled with the result of calling the closure `f`. The return values from `f`
+ //// will end up in the `SmallVec` in the order they have been generated.
+ ///
+ /// If `new_len` is less than `len`, the `SmallVec` is simply truncated.
+ ///
+ /// This method uses a closure to create new values on every push. If you'd rather `Clone` a given
+ /// value, use `resize`. If you want to use the `Default` trait to generate values, you can pass
+ /// `Default::default()` as the second argument.
+ ///
+ /// Added for std::vec::Vec compatibility (added in Rust 1.33.0)
+ ///
+ /// ```
+ /// # use smallvec::{smallvec, SmallVec};
+ /// let mut vec : SmallVec<[_; 4]> = smallvec![1, 2, 3];
+ /// vec.resize_with(5, Default::default);
+ /// assert_eq!(&*vec, &[1, 2, 3, 0, 0]);
+ ///
+ /// let mut vec : SmallVec<[_; 4]> = smallvec![];
+ /// let mut p = 1;
+ /// vec.resize_with(4, || { p *= 2; p });
+ /// assert_eq!(&*vec, &[2, 4, 8, 16]);
+ /// ```
+ pub fn resize_with<F>(&mut self, new_len: usize, f: F)
+ where
+ F: FnMut() -> A::Item,
+ {
+ let old_len = self.len();
+ if old_len < new_len {
+ let mut f = f;
+ let additional = new_len - old_len;
+ self.reserve(additional);
+ for _ in 0..additional {
+ self.push(f());
+ }
+ } else if old_len > new_len {
+ self.truncate(new_len);
+ }
+ }
+
/// Creates a `SmallVec` directly from the raw components of another
/// `SmallVec`.
///
@@ -1160,7 +1240,7 @@
/// }
#[inline]
pub unsafe fn from_raw_parts(ptr: *mut A::Item, length: usize, capacity: usize) -> SmallVec<A> {
- assert!(capacity > A::size());
+ assert!(capacity > Self::inline_capacity());
SmallVec {
capacity,
data: SmallVecData::from_heap(ptr, length),
@@ -1177,7 +1257,7 @@
/// For slices of `Copy` types, this is more efficient than `SmallVec::from(slice)`.
pub fn from_slice(slice: &[A::Item]) -> Self {
let len = slice.len();
- if len <= A::size() {
+ if len <= Self::inline_capacity() {
SmallVec {
capacity: len,
data: SmallVecData::from_inline(unsafe {
@@ -1258,7 +1338,7 @@
/// assert_eq!(v, SmallVec::from_buf(['d', 'd']));
/// ```
pub fn from_elem(elem: A::Item, n: usize) -> Self {
- if n > A::size() {
+ if n > Self::inline_capacity() {
vec![elem; n].into()
} else {
let mut v = SmallVec::<A>::new();
@@ -1466,6 +1546,7 @@
}
}
+#[allow(deprecated)]
impl<A: Array> ExtendFromSlice<A::Item> for SmallVec<A>
where
A::Item: Copy,
@@ -1559,11 +1640,7 @@
{
#[inline]
fn clone(&self) -> SmallVec<A> {
- let mut new_vector = SmallVec::with_capacity(self.len());
- for element in self.iter() {
- new_vector.push((*element).clone())
- }
- new_vector
+ SmallVec::from(self.as_slice())
}
}
@@ -1778,7 +1855,9 @@
#[cfg(feature = "const_generics")]
unsafe impl<T, const N: usize> Array for [T; N] {
type Item = T;
- fn size() -> usize { N }
+ fn size() -> usize {
+ N
+ }
}
#[cfg(not(feature = "const_generics"))]
@@ -1801,13 +1880,15 @@
);
/// Convenience trait for constructing a `SmallVec`
-pub trait ToSmallVec<A:Array> {
+pub trait ToSmallVec<A: Array> {
/// Construct a new `SmallVec` from a slice.
fn to_smallvec(&self) -> SmallVec<A>;
}
-impl<A:Array> ToSmallVec<A> for [A::Item]
- where A::Item: Copy {
+impl<A: Array> ToSmallVec<A> for [A::Item]
+where
+ A::Item: Copy,
+{
#[inline]
fn to_smallvec(&self) -> SmallVec<A> {
SmallVec::from_slice(self)
@@ -2666,4 +2747,14 @@
fn const_generics() {
let _v = SmallVec::<[i32; 987]>::default();
}
+
+ #[test]
+ fn empty_macro() {
+ let _v: SmallVec<[u8; 1]> = smallvec![];
+ }
+
+ #[test]
+ fn zero_size_items() {
+ SmallVec::<[(); 0]>::new().push(());
+ }
}
diff --git a/tests/macro.rs b/tests/macro.rs
new file mode 100644
index 0000000..fa52e79
--- /dev/null
+++ b/tests/macro.rs
@@ -0,0 +1,24 @@
+/// This file tests `smallvec!` without actually having the macro in scope.
+/// This forces any recursion to use a `$crate` prefix to reliably find itself.
+
+#[test]
+fn smallvec() {
+ let mut vec: smallvec::SmallVec<[i32; 2]>;
+
+ macro_rules! check {
+ ($init:tt) => {
+ vec = smallvec::smallvec! $init;
+ assert_eq!(*vec, *vec! $init);
+ }
+ }
+
+ check!([0; 0]);
+ check!([1; 1]);
+ check!([2; 2]);
+ check!([3; 3]);
+
+ check!([]);
+ check!([1]);
+ check!([1, 2]);
+ check!([1, 2, 3]);
+}