feat: add impl From<CompactString> for String

compact_str/src/lib.rs

@@ -610,6 +610,12 @@ impl From<Box<str>> for CompactString {
     }
 }
 
+impl From<CompactString> for String {
+    fn from(s: CompactString) -> Self {
+        s.repr.into_string()
+    }
+}
+
 impl FromStr for CompactString {
     type Err = core::convert::Infallible;
     fn from_str(s: &str) -> Result<CompactString, Self::Err> {

compact_str/src/repr/boxed/mod.rs

@@ -151,6 +151,20 @@ impl BoxString {
         }
     }
 
+    #[inline]
+    pub fn into_string(self) -> String {
+        // Ensure that we don't free the data we are transferring to `String`
+        let this = ManuallyDrop::new(self);
+
+        // SAFETY:
+        // * The memory in `ptr` was previously allocated by the same allocator the standard library
+        //   uses, with a required alignment of exactly 1.
+        // * `length` is less than or equal to capacity, due to internal invaraints.
+        // * `capacity` is correctly maintained internally.
+        // * `BoxString` only ever contains valid UTF-8.
+        unsafe { String::from_raw_parts(this.ptr.as_ptr(), this.len, this.capacity()) }
+    }
+
     #[inline]
     pub fn from_box_str(b: Box<str>) -> Self {
         match Capacity::new(b.len()) {

compact_str/src/repr/heap.rs

@@ -38,6 +38,11 @@ impl HeapString {
         HeapString { string }
     }
 
+    #[inline]
+    pub fn into_string(self) -> String {
+        self.string.into_string()
+    }
+
     #[inline]
     pub fn from_box_str(b: Box<str>) -> Self {
         let string = BoxString::from_box_str(b);

compact_str/src/repr/mod.rs

@@ -122,6 +122,22 @@ impl Repr {
         }
     }
 
+    #[inline]
+    pub fn into_string(self) -> String {
+        if self.capacity() == 0 {
+            String::new()
+        } else {
+            match self.cast_into() {
+                StrongIntoRepr::Inline(inline) => String::from(inline.as_str()),
+                StrongIntoRepr::Heap(heap) => {
+                    // `HeapString::into_string()` takes ownership and
+                    // is responsible for avoiding a double-free.
+                    ManuallyDrop::into_inner(heap).into_string()
+                }
+            }
+        }
+    }
+
     #[inline]
     pub fn from_box_str(b: Box<str>) -> Self {
         if b.len() == 0 {
@@ -272,6 +288,20 @@ impl Repr {
         }
     }
 
+    #[inline(always)]
+    fn cast_into(self) -> StrongIntoRepr {
+        match self.discriminant() {
+            Discriminant::Heap => {
+                // SAFETY: We checked the discriminant to make sure the union is `heap`
+                StrongIntoRepr::Heap(unsafe { self.into_union().heap })
+            }
+            Discriminant::Inline => {
+                // SAFETY: We checked the discriminant to make sure the union is `inline`
+                StrongIntoRepr::Inline(unsafe { self.into_union().inline })
+            }
+        }
+    }
+
     #[inline(always)]
     const fn from_inline(repr: InlineString) -> Self {
         // SAFETY: An `InlineString` and `Repr` have the same size
@@ -295,6 +325,12 @@ impl Repr {
         // SAFETY: An `ReprUnion` and `Repr` have the same size
         unsafe { &mut *(self as *mut _ as *mut _) }
     }
+
+    #[inline(always)]
+    fn into_union(self) -> ReprUnion {
+        // SAFETY: An `ReprUnion` and `Repr` have the same size
+        unsafe { std::mem::transmute(self) }
+    }
 }
 
 impl Clone for Repr {
@@ -501,6 +537,12 @@ impl<'a> MutStrongRepr<'a> {
     }
 }
 
+#[derive(Debug)]
+enum StrongIntoRepr {
+    Inline(InlineString),
+    Heap(ManuallyDrop<HeapString>),
+}
+
 crate::asserts::assert_size_eq!(ReprUnion, Repr, Option<Repr>, String, Option<String>);
 
 #[cfg(target_pointer_width = "64")]

compact_str/src/tests.rs

@@ -160,6 +160,16 @@ fn proptest_reserve_and_write_bytes_allocated_properly(#[strategy(rand_unicode()
     prop_assert_eq!(compact.is_heap_allocated(), word.len() > MAX_SIZE);
 }
 
+#[proptest]
+#[cfg_attr(miri, ignore)]
+fn proptest_arbitrary_compact_string_converts_to_string(#[strategy(rand_unicode())] word: String) {
+    let compact = CompactString::new(&word);
+    let result = String::from(compact);
+
+    prop_assert_eq!(result.len(), word.len());
+    prop_assert_eq!(result, word);
+}
+
 #[proptest]
 #[cfg_attr(miri, ignore)]
 fn proptest_extend_chars_allocated_properly(
@@ -695,3 +705,131 @@ fn test_to_compact_string() {
         format_compact!("0{}67890123456789{}", "12345", 999999)
     );
 }
+
+#[test]
+fn test_into_string_large_string_with_excess_capacity() {
+    let mut string = String::with_capacity(128);
+    string.push_str("abcdefghijklmnopqrstuvwxyz");
+    let str_addr = string.as_ptr();
+    let str_len = string.len();
+    let str_cap = string.capacity();
+
+    let compact = CompactString::from(string);
+    let new_string = String::from(compact);
+    let new_str_addr = new_string.as_ptr();
+    let new_str_len = new_string.len();
+    let new_str_cap = new_string.capacity();
+
+    assert_eq!(str_addr, new_str_addr);
+    assert_eq!(str_len, new_str_len);
+    assert_eq!(str_cap, new_str_cap);
+}
+
+#[test]
+fn test_into_string_small_string_with_excess_capacity() {
+    let mut string = String::with_capacity(128);
+    string.push_str("abcdef");
+    let str_addr = string.as_ptr();
+    let str_len = string.len();
+    let str_cap = string.capacity();
+
+    let compact = CompactString::from(string);
+    let new_string = String::from(compact);
+    let new_str_addr = new_string.as_ptr();
+    let new_str_len = new_string.len();
+    let new_str_cap = new_string.capacity();
+
+    // If small boxed strings are eagerly compacted, the address and capacity assertions won't hold.
+    // Compaction is not eager, so these should hold.
+    assert_eq!(str_addr, new_str_addr);
+    assert_eq!(str_len, new_str_len);
+    assert_eq!(str_cap, new_str_cap);
+}
+
+#[test]
+fn test_into_string_small_string_with_no_excess_capacity() {
+    let string = String::from("abcdef");
+    let str_addr = string.as_ptr();
+    let str_len = string.len();
+    let str_cap = string.capacity();
+
+    let compact = CompactString::from(string);
+    let new_string = String::from(compact);
+    let new_str_addr = new_string.as_ptr();
+    let new_str_len = new_string.len();
+    let new_str_cap = new_string.capacity();
+
+    // If small boxed strings are eagerly compacted, the address assertion won't hold.
+    // Compaction is not eager, so these should hold.
+    assert_eq!(str_addr, new_str_addr);
+    assert_eq!(str_len, new_str_len);
+    assert_eq!(str_cap, new_str_cap);
+}
+
+#[test]
+fn test_into_string_empty_string() {
+    let string = String::new();
+    let str_addr = string.as_ptr();
+    let str_len = string.len();
+    let str_cap = string.capacity();
+
+    let compact = CompactString::from(string);
+    let new_string = String::from(compact);
+    let new_str_addr = new_string.as_ptr();
+    let new_str_len = new_string.len();
+    let new_str_cap = new_string.capacity();
+
+    assert_eq!(str_addr, new_str_addr);
+    assert_eq!(str_len, new_str_len);
+    assert_eq!(str_cap, new_str_cap);
+}
+
+#[test]
+fn test_into_string_small_str() {
+    let data = "abcdef";
+    let str_addr = data.as_ptr();
+    let str_len = data.len();
+
+    let compact = CompactString::from(data);
+    let new_string = String::from(compact);
+    let new_str_addr = new_string.as_ptr();
+    let new_str_len = new_string.len();
+    let new_str_cap = new_string.capacity();
+
+    assert_ne!(str_addr, new_str_addr);
+    assert_eq!(str_len, new_str_len);
+    assert_eq!(str_len, new_str_cap);
+}
+
+#[test]
+fn test_into_string_long_str() {
+    let data = "abcdefghijklmnopqrstuvwxyz";
+    let str_addr = data.as_ptr();
+    let str_len = data.len();
+
+    let compact = CompactString::from(data);
+    let new_string = String::from(compact);
+    let new_str_addr = new_string.as_ptr();
+    let new_str_len = new_string.len();
+    let new_str_cap = new_string.capacity();
+
+    assert_ne!(str_addr, new_str_addr);
+    assert_eq!(str_len, new_str_len);
+    assert_eq!(str_len, new_str_cap);
+}
+
+#[test]
+fn test_into_string_empty_str() {
+    let data = "";
+    let str_len = data.len();
+
+    let compact = CompactString::from(data);
+    let new_string = String::from(compact);
+    let new_str_addr = new_string.as_ptr();
+    let new_str_len = new_string.len();
+    let new_str_cap = new_string.capacity();
+
+    assert_eq!(String::new().as_ptr(), new_str_addr);
+    assert_eq!(str_len, new_str_len);
+    assert_eq!(str_len, new_str_cap);
+}