From f81cd87eeae2b02ebfcf309764cd9e648040b988 Mon Sep 17 00:00:00 2001 From: Finn Bear Date: Wed, 19 Oct 2022 19:07:45 -0700 Subject: [PATCH 1/2] Copy of #102941. --- library/alloc/src/string.rs | 31 ++++++++++++++++++++++++++++++- 1 file changed, 30 insertions(+), 1 deletion(-) diff --git a/library/alloc/src/string.rs b/library/alloc/src/string.rs index 983376a282be5..9bda7f5dc3735 100644 --- a/library/alloc/src/string.rs +++ b/library/alloc/src/string.rs @@ -67,7 +67,7 @@ use core::str::Utf8Chunks; use crate::borrow::{Cow, ToOwned}; use crate::boxed::Box; use crate::collections::TryReserveError; -use crate::str::{self, Chars, Utf8Error}; +use crate::str::{self, from_utf8_unchecked_mut, Chars, Utf8Error}; #[cfg(not(no_global_oom_handling))] use crate::str::{from_boxed_utf8_unchecked, FromStr}; use crate::vec::Vec; @@ -2691,6 +2691,35 @@ impl From for Box { fn from(s: String) -> Box { s.into_boxed_str() } + + /// Consumes and leaks the `String`, returning a mutable reference to the contents, + /// `&'a mut str`. + /// + /// This is mainly useful for data that lives for the remainder of + /// the program's life. Dropping the returned reference will cause a memory + /// leak. + /// + /// It does not reallocate or shrink the `String`, + /// so the leaked allocation may include unused capacity that is not part + /// of the returned slice. + /// + /// # Examples + /// + /// Simple usage: + /// + /// ``` + /// #![feature(string_leak)] + /// + /// let x = String::from("bucket"); + /// let static_ref: &'static mut str = x.leak(); + /// assert_eq!(static_ref, "bucket"); + /// ``` + #[unstable(feature = "string_leak", issue = "102929")] + #[inline] + pub fn leak(self) -> &'static mut str { + let slice = self.vec.leak(); + unsafe { from_utf8_unchecked_mut(slice) } + } } #[cfg(not(no_global_oom_handling))] From 4f44d6253d02484400afa315a1f0306f4cf35d16 Mon Sep 17 00:00:00 2001 From: Finn Bear Date: Wed, 19 Oct 2022 19:15:58 -0700 Subject: [PATCH 2/2] Put fn in the right place. --- library/alloc/src/string.rs | 58 ++++++++++++++++++------------------- 1 file changed, 29 insertions(+), 29 deletions(-) diff --git a/library/alloc/src/string.rs b/library/alloc/src/string.rs index 9bda7f5dc3735..209abfac6bbf9 100644 --- a/library/alloc/src/string.rs +++ b/library/alloc/src/string.rs @@ -1849,6 +1849,35 @@ impl String { let slice = self.vec.into_boxed_slice(); unsafe { from_boxed_utf8_unchecked(slice) } } + + /// Consumes and leaks the `String`, returning a mutable reference to the contents, + /// `&'a mut str`. + /// + /// This is mainly useful for data that lives for the remainder of + /// the program's life. Dropping the returned reference will cause a memory + /// leak. + /// + /// It does not reallocate or shrink the `String`, + /// so the leaked allocation may include unused capacity that is not part + /// of the returned slice. + /// + /// # Examples + /// + /// Simple usage: + /// + /// ``` + /// #![feature(string_leak)] + /// + /// let x = String::from("bucket"); + /// let static_ref: &'static mut str = x.leak(); + /// assert_eq!(static_ref, "bucket"); + /// ``` + #[unstable(feature = "string_leak", issue = "102929")] + #[inline] + pub fn leak(self) -> &'static mut str { + let slice = self.vec.leak(); + unsafe { from_utf8_unchecked_mut(slice) } + } } impl FromUtf8Error { @@ -2691,35 +2720,6 @@ impl From for Box { fn from(s: String) -> Box { s.into_boxed_str() } - - /// Consumes and leaks the `String`, returning a mutable reference to the contents, - /// `&'a mut str`. - /// - /// This is mainly useful for data that lives for the remainder of - /// the program's life. Dropping the returned reference will cause a memory - /// leak. - /// - /// It does not reallocate or shrink the `String`, - /// so the leaked allocation may include unused capacity that is not part - /// of the returned slice. - /// - /// # Examples - /// - /// Simple usage: - /// - /// ``` - /// #![feature(string_leak)] - /// - /// let x = String::from("bucket"); - /// let static_ref: &'static mut str = x.leak(); - /// assert_eq!(static_ref, "bucket"); - /// ``` - #[unstable(feature = "string_leak", issue = "102929")] - #[inline] - pub fn leak(self) -> &'static mut str { - let slice = self.vec.leak(); - unsafe { from_utf8_unchecked_mut(slice) } - } } #[cfg(not(no_global_oom_handling))]