Bump::alloc_str

This is similar to allocating slices, but for string slices. Because
string slices are a strange beast and none of the other methods can be
used *directly*. It could be done at the caller side, but then the user
would need to use `unsafe` which might be unacceptable in business-logic
applications or crates (or be content with the needless check for utf8
which is already guaranteed to be valid).

CHANGELOG.md

@@ -1,3 +1,6 @@
+* Add `alloc_str`, which is similar to `alloc_slice_*` methods, but works on
+  string slices.
+
 # 2.6.0
 
 Released 2019-08-19.

src/lib.rs

@@ -116,6 +116,7 @@ use core::marker::PhantomData;
 use core::mem;
 use core::ptr::{self, NonNull};
 use core::slice;
+use core::str;
 use core_alloc::alloc::{alloc, dealloc, Layout};
 
 /// An arena to bump allocate into.
@@ -640,6 +641,29 @@ impl Bump {
         }
     }
 
+    /// `Copy` a string slice into this `Bump` and return an exclusive reference to it.
+    ///
+    /// ## Panics
+    ///
+    /// Panics if reserving space for the string would cause an overflow.
+    ///
+    /// ## Example
+    ///
+    /// ```
+    /// let bump = bumpalo::Bump::new();
+    /// let hello = bump.alloc_str("hello world");
+    /// assert_eq!("hello world", hello);
+    /// ```
+    #[inline(always)]
+    #[allow(clippy::mut_from_ref)]
+    pub fn alloc_str(&self, src: &str) -> &mut str {
+        let buffer = self.alloc_slice_copy(src.as_bytes());
+        unsafe {
+            // This is OK, because it already came in as str, so it is guaranteed to be utf8
+            str::from_utf8_unchecked_mut(buffer)
+        }
+    }
+
     /// Allocates a new slice of size `len` into this `Bump` and returns an
     /// exclusive reference to the copy.
     ///

tests/quickchecks.rs

@@ -219,4 +219,12 @@ quickcheck! {
             allocated.push(range);
         }
     }
+
+    fn alloc_strs(allocs: Vec<String>) -> () {
+        let b = Bump::new();
+        let allocated: Vec<&str> = allocs.iter().map(|s| b.alloc_str(s) as &_).collect();
+        for (val, alloc) in allocs.into_iter().zip(allocated) {
+            assert_eq!(val, alloc);
+        }
+    }
 }