Remove an unnecessary test in grow_{amortized,exact}().

As long as these functions are called after `needs_to_grow()`, the
capacity overflow check has the same result as the special zero-sized
type check.

This commit removes that check, documents the `needs_to_grow()`
constraint, and updates the test accordingly.

Author: nnethercote

library/alloc/src/raw_vec.rs

@@ -370,6 +370,10 @@ impl<T, A: Allocator> RawVec<T, A> {
         self.cap = Self::capacity_from_bytes(ptr.len());
     }
 
+    // This method must only be called after `needs_to_grow(len, additional)`
+    // succeeds. Otherwise, if `T` is zero-sized it will cause a divide by
+    // zero.
+    //
     // This method is usually instantiated many times. So we want it to be as
     // small as possible, to improve compile times. But we also want as much of
     // its contents to be statically computable as possible, to make the
@@ -381,13 +385,9 @@ impl<T, A: Allocator> RawVec<T, A> {
         // This is ensured by the calling contexts.
         debug_assert!(additional > 0);
 
-        if mem::size_of::<T>() == 0 {
-            // Since we return a capacity of `usize::MAX` when `elem_size` is
-            // 0, getting to here necessarily means the `RawVec` is overfull.
-            return Err(CapacityOverflow.into());
-        }
-
-        // Nothing we can really do about these checks, sadly.
+        // Nothing we can really do about these checks, sadly. (If this method
+        // is called for a zero-sized `T` after `needs_to_grow()` has
+        // succeeded, this early return will occur.)
         let required_cap = len.checked_add(additional).ok_or(CapacityOverflow)?;
 
         // This guarantees exponential growth. The doubling cannot overflow
@@ -403,16 +403,17 @@ impl<T, A: Allocator> RawVec<T, A> {
         Ok(())
     }
 
+    // This method must only be called after `needs_to_grow(len, additional)`
+    // succeeds. Otherwise, if `T` is zero-sized it will cause a divide by
+    // zero.
+    //
     // The constraints on this method are much the same as those on
     // `grow_amortized`, but this method is usually instantiated less often so
     // it's less critical.
     fn grow_exact(&mut self, len: usize, additional: usize) -> Result<(), TryReserveError> {
-        if mem::size_of::<T>() == 0 {
-            // Since we return a capacity of `usize::MAX` when the type size is
-            // 0, getting to here necessarily means the `RawVec` is overfull.
-            return Err(CapacityOverflow.into());
-        }
-
+        // Nothing we can really do about these checks, sadly. (If this method
+        // is called for a zero-sized `T` after `needs_to_grow()` has
+        // succeeded, this early return will occur.)
         let cap = len.checked_add(additional).ok_or(CapacityOverflow)?;
         let new_layout = Layout::array::<T>(cap);
 

library/alloc/src/raw_vec/tests.rs

@@ -135,11 +135,11 @@ fn zst() {
     assert_eq!(v.try_reserve_exact(101, usize::MAX - 100), cap_err);
     zst_sanity(&v);
 
-    assert_eq!(v.grow_amortized(100, usize::MAX - 100), cap_err);
+    //v.grow_amortized(100, usize::MAX - 100); // panics, in `zst_grow_amortized_panic` below
     assert_eq!(v.grow_amortized(101, usize::MAX - 100), cap_err);
     zst_sanity(&v);
 
-    assert_eq!(v.grow_exact(100, usize::MAX - 100), cap_err);
+    //v.grow_exact(100, usize::MAX - 100); // panics, in `zst_grow_exact_panic` below
     assert_eq!(v.grow_exact(101, usize::MAX - 100), cap_err);
     zst_sanity(&v);
 }
@@ -161,3 +161,25 @@ fn zst_reserve_exact_panic() {
 
     v.reserve_exact(101, usize::MAX - 100);
 }
+
+#[test]
+#[should_panic(expected = "divide by zero")]
+fn zst_grow_amortized_panic() {
+    let mut v: RawVec<ZST> = RawVec::new();
+    zst_sanity(&v);
+
+    // This shows the divide by zero that occurs when `grow_amortized()` is
+    // called when `needs_to_grow()` would have returned `false`.
+    let _ = v.grow_amortized(100, usize::MAX - 100);
+}
+
+#[test]
+#[should_panic(expected = "divide by zero")]
+fn zst_grow_exact_panic() {
+    let mut v: RawVec<ZST> = RawVec::new();
+    zst_sanity(&v);
+
+    // This shows the divide by zero that occurs when `grow_amortized()` is
+    // called when `needs_to_grow()` would have returned `false`.
+    let _ = v.grow_exact(100, usize::MAX - 100);
+}