Adding COOP_PREFERRED to Cow, ToOwned...

Author: peter-lyons-kehl

library/alloc/src/borrow.rs

@@ -17,6 +17,9 @@ use crate::string::String;
 
 use Cow::*;
 
+// @FIXME check if used & needed
+pub(crate) const BORROW_COOP_PREFERRED: bool = DEFAULT_COOP_PREFERRED!();
+
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'a, B: ?Sized, const COOP_PREFERRED: bool> Borrow<B> for Cow<'a, B, COOP_PREFERRED>
 where
@@ -344,9 +347,10 @@ where
 
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_const_unstable(feature = "const_deref", issue = "88955")]
-impl<B: ?Sized + ToOwned> const Deref for Cow<'_, B>
+impl<B: ?Sized + ToOwned<COOP_PREFERRED>, const COOP_PREFERRED: bool> const Deref for Cow<'_, B, COOP_PREFERRED>
 where
     B::Owned: ~const Borrow<B>,
+    [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
 {
     type Target = B;
 
@@ -359,12 +363,18 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<B: ?Sized> Eq for Cow<'_, B> where B: Eq + ToOwned {}
+impl<B: ?Sized, const COOP_PREFERRED: bool> Eq for Cow<'_, B, COOP_PREFERRED>
+where
+    B: Eq + ToOwned<COOP_PREFERRED>,
+    [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+
+   {}
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<B: ?Sized> Ord for Cow<'_, B>
+impl<B: ?Sized, const COOP_PREFERRED: bool> Ord for Cow<'_, B, COOP_PREFERRED>
 where
-    B: Ord + ToOwned,
+    B: Ord + ToOwned<COOP_PREFERRED>,
+    [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
 {
     #[inline]
     fn cmp(&self, other: &Self) -> Ordering {
@@ -373,24 +383,26 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, 'b, B: ?Sized, C: ?Sized> PartialEq<Cow<'b, C>> for Cow<'a, B>
+impl<'a, 'b, B: ?Sized, C: ?Sized, const COOP_PREFERRED: bool> PartialEq<Cow<'b, C, COOP_PREFERRED>> for Cow<'a, B, COOP_PREFERRED>
 where
-    B: PartialEq<C> + ToOwned,
-    C: ToOwned,
+    B: PartialEq<C> + ToOwned<COOP_PREFERRED>,
+    C: ToOwned<COOP_PREFERRED>,
+    [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
 {
     #[inline]
-    fn eq(&self, other: &Cow<'b, C>) -> bool {
+    fn eq(&self, other: &Cow<'b, C, COOP_PREFERRED>) -> bool {
         PartialEq::eq(&**self, &**other)
     }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, B: ?Sized> PartialOrd for Cow<'a, B>
+impl<'a, B: ?Sized, const COOP_PREFERRED: bool> PartialOrd for Cow<'a, B, COOP_PREFERRED>
 where
-    B: PartialOrd + ToOwned,
+    B: PartialOrd + ToOwned<COOP_PREFERRED>,
+    [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
 {
     #[inline]
-    fn partial_cmp(&self, other: &Cow<'a, B>) -> Option<Ordering> {
+    fn partial_cmp(&self, other: &Cow<'a, B, COOP_PREFERRED>) -> Option<Ordering> {
         PartialOrd::partial_cmp(&**self, &**other)
     }
 }
@@ -436,9 +448,10 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<B: ?Sized> Hash for Cow<'_, B>
+impl<B: ?Sized, const COOP_PREFERRED: bool> Hash for Cow<'_, B, COOP_PREFERRED>
 where
-    B: Hash + ToOwned,
+    B: Hash + ToOwned<COOP_PREFERRED>,
+    [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
 {
     #[inline]
     fn hash<H: Hasher>(&self, state: &mut H) {
@@ -447,16 +460,20 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: ?Sized + ToOwned> AsRef<T> for Cow<'_, T> {
+impl<T: ?Sized + ToOwned<COOP_PREFERRED>, const COOP_PREFERRED: bool> AsRef<T> for Cow<'_, T, COOP_PREFERRED>
+where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
     fn as_ref(&self) -> &T {
         self
     }
 }
 
 #[cfg(not(no_global_oom_handling))]
 #[stable(feature = "cow_add", since = "1.14.0")]
-impl<'a> Add<&'a str> for Cow<'a, str> {
-    type Output = Cow<'a, str>;
+impl<'a, const COOP_PREFERRED: bool> Add<&'a str> for Cow<'a, str, COOP_PREFERRED>
+where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
+    type Output = Cow<'a, str, COOP_PREFERRED>;
 
     #[inline]
     fn add(mut self, rhs: &'a str) -> Self::Output {
@@ -467,19 +484,23 @@ impl<'a> Add<&'a str> for Cow<'a, str> {
 
 #[cfg(not(no_global_oom_handling))]
 #[stable(feature = "cow_add", since = "1.14.0")]
-impl<'a> Add<Cow<'a, str>> for Cow<'a, str> {
-    type Output = Cow<'a, str>;
+impl<'a, const COOP_PREFERRED: bool> Add<Cow<'a, str, COOP_PREFERRED>> for Cow<'a, str, COOP_PREFERRED>
+where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
+    type Output = Cow<'a, str, COOP_PREFERRED>;
 
     #[inline]
-    fn add(mut self, rhs: Cow<'a, str>) -> Self::Output {
+    fn add(mut self, rhs: Cow<'a, str, COOP_PREFERRED>) -> Self::Output {
         self += rhs;
         self
     }
 }
 
 #[cfg(not(no_global_oom_handling))]
 #[stable(feature = "cow_add", since = "1.14.0")]
-impl<'a> AddAssign<&'a str> for Cow<'a, str> {
+impl<'a, const COOP_PREFERRED: bool> AddAssign<&'a str> for Cow<'a, str, COOP_PREFERRED>
+where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
     fn add_assign(&mut self, rhs: &'a str) {
         if self.is_empty() {
             *self = Cow::Borrowed(rhs)
@@ -496,8 +517,10 @@ impl<'a> AddAssign<&'a str> for Cow<'a, str> {
 
 #[cfg(not(no_global_oom_handling))]
 #[stable(feature = "cow_add", since = "1.14.0")]
-impl<'a> AddAssign<Cow<'a, str>> for Cow<'a, str> {
-    fn add_assign(&mut self, rhs: Cow<'a, str>) {
+impl<'a, const COOP_PREFERRED: bool> AddAssign<Cow<'a, str, COOP_PREFERRED>> for Cow<'a, str, COOP_PREFERRED>
+where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
+    fn add_assign(&mut self, rhs: Cow<'a, str, COOP_PREFERRED>) {
         if self.is_empty() {
             *self = rhs
         } else if !rhs.is_empty() {

library/alloc/src/ffi/c_str.rs

@@ -496,7 +496,10 @@ impl CString {
     /// ```
     #[must_use = "`self` will be dropped if the result is not used"]
     #[stable(feature = "cstring_into", since = "1.7.0")]
-    pub fn into_bytes(self) -> Vec<u8> {
+    pub fn into_bytes<const COOP_PREFERRED: bool>(self) -> Vec<u8, Global, COOP_PREFERRED>
+    where
+        [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+    {
         let mut vec = into_vec(self.into_inner());
         let _nul = vec.pop();
         debug_assert_eq!(_nul, Some(0u8));
@@ -726,12 +729,14 @@ impl fmt::Debug for CString {
 
 #[stable(feature = "cstring_into", since = "1.7.0")]
 #[allow(unused_braces)]
-impl From<CString> for Vec<u8, Global, {DEFAULT_COOP_PREFERRED!()}> {
+impl<const COOP_PREFERRED: bool> From<CString> for Vec<u8, Global, COOP_PREFERRED>
+where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
     /// Converts a [`CString`] into a <code>[Vec]<[u8]></code>.
     ///
     /// The conversion consumes the [`CString`], and removes the terminating NUL byte.
     #[inline]
-    fn from(s: CString) -> Vec<u8> {
+    fn from(s: CString) -> Vec<u8, Global, COOP_PREFERRED> {
         s.into_bytes()
     }
 }
@@ -741,7 +746,8 @@ impl Default for CString {
     /// Creates an empty `CString`.
     fn default() -> CString {
         let a: &CStr = Default::default();
-        a.to_owned()
+        // false = no need for co-alloc metadata, since it would get lost once converted to Box.
+        <CStr as ToOwned<false>>::to_owned(a)
     }
 }
 
@@ -754,11 +760,13 @@ impl Borrow<CStr> for CString {
 }
 
 #[stable(feature = "cstring_from_cow_cstr", since = "1.28.0")]
-impl<'a> From<Cow<'a, CStr>> for CString {
+impl<'a, const COOP_PREFERRED: bool> From<Cow<'a, CStr, COOP_PREFERRED>> for CString
+where     [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
     /// Converts a `Cow<'a, CStr>` into a `CString`, by copying the contents if they are
     /// borrowed.
     #[inline]
-    fn from(s: Cow<'a, CStr>) -> Self {
+    fn from(s: Cow<'a, CStr, COOP_PREFERRED>) -> Self {
         s.into_owned()
     }
 }
@@ -775,11 +783,13 @@ impl From<&CStr> for Box<CStr> {
 }
 
 #[stable(feature = "box_from_cow", since = "1.45.0")]
-impl From<Cow<'_, CStr>> for Box<CStr> {
+impl<const COOP_PREFERRED: bool> From<Cow<'_, CStr, COOP_PREFERRED>> for Box<CStr>
+where [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
     /// Converts a `Cow<'a, CStr>` into a `Box<CStr>`,
     /// by copying the contents if they are borrowed.
     #[inline]
-    fn from(cow: Cow<'_, CStr>) -> Box<CStr> {
+    fn from(cow: Cow<'_, CStr, COOP_PREFERRED>) -> Box<CStr> {
         match cow {
             Cow::Borrowed(s) => Box::from(s),
             Cow::Owned(s) => Box::from(s),
@@ -838,28 +848,33 @@ impl From<CString> for Box<CStr> {
 }
 
 #[stable(feature = "cow_from_cstr", since = "1.28.0")]
-impl<'a> From<CString> for Cow<'a, CStr> {
+#[allow(unused_braces)]
+impl<'a> From<CString> for Cow<'a, CStr, { DEFAULT_COOP_PREFERRED!() }> {
     /// Converts a [`CString`] into an owned [`Cow`] without copying or allocating.
     #[inline]
-    fn from(s: CString) -> Cow<'a, CStr> {
+    fn from(s: CString) -> Cow<'a, CStr, { DEFAULT_COOP_PREFERRED!() }> {
         Cow::Owned(s)
     }
 }
 
 #[stable(feature = "cow_from_cstr", since = "1.28.0")]
-impl<'a> From<&'a CStr> for Cow<'a, CStr> {
+#[allow(unused_braces)]
+impl<'a> From<&'a CStr> for Cow<'a, CStr, { DEFAULT_COOP_PREFERRED!() }> {
     /// Converts a [`CStr`] into a borrowed [`Cow`] without copying or allocating.
     #[inline]
-    fn from(s: &'a CStr) -> Cow<'a, CStr> {
+    fn from(s: &'a CStr) -> Cow<'a, CStr, { DEFAULT_COOP_PREFERRED!() }> {
         Cow::Borrowed(s)
     }
 }
 
 #[stable(feature = "cow_from_cstr", since = "1.28.0")]
-impl<'a> From<&'a CString> for Cow<'a, CStr> {
+impl<'a, const COOP_PREFERRED: bool> From<&'a CString> for Cow<'a, CStr, COOP_PREFERRED>
+where
+    [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
     /// Converts a `&`[`CString`] into a borrowed [`Cow`] without copying or allocating.
     #[inline]
-    fn from(s: &'a CString) -> Cow<'a, CStr> {
+    fn from(s: &'a CString) -> Cow<'a, CStr, COOP_PREFERRED> {
         Cow::Borrowed(s.as_c_str())
     }
 }
@@ -1017,7 +1032,11 @@ impl fmt::Display for IntoStringError {
 }
 
 #[stable(feature = "cstr_borrow", since = "1.3.0")]
-impl ToOwned for CStr {
+// @FIXME try remove COOP_PREFERRED and have ToOwned<_>
+impl<const COOP_PREFERRED: bool> ToOwned<COOP_PREFERRED> for CStr
+where
+    [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
     type Owned = CString;
 
     fn to_owned(&self) -> CString {
@@ -1034,7 +1053,8 @@ impl ToOwned for CStr {
 #[stable(feature = "cstring_asref", since = "1.7.0")]
 impl From<&CStr> for CString {
     fn from(s: &CStr) -> CString {
-        s.to_owned()
+        // false = no need for co-alloc metadata, since it would get lost once converted to Box.
+        <CStr as ToOwned<false>>::to_owned(s)
     }
 }
 
@@ -1102,9 +1122,11 @@ impl CStr {
     #[must_use = "this returns the result of the operation, \
                   without modifying the original"]
     #[stable(feature = "cstr_to_str", since = "1.4.0")]
-    pub fn to_string_lossy(&self) -> Cow<'_, str, false> {
+    pub fn to_string_lossy<const COOP_PREFERRED: bool>(&self) -> Cow<'_, str, COOP_PREFERRED>
+    where    [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+    {
         // false = no need for co-alloc metadata, since it would get lost once converted to the slice.
-        String::<false>::from_utf8_lossy(self.to_bytes())
+        String::<COOP_PREFERRED>::from_utf8_lossy(self.to_bytes())
     }
 
     /// Converts a <code>[Box]<[CStr]></code> into a [`CString`] without copying or allocating.

library/alloc/src/slice.rs

@@ -852,22 +852,26 @@ where
     }
 }
 
-// COOP_NOT_POSSIBLE
 #[cfg(not(no_global_oom_handling))]
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Clone> ToOwned for [T] {
-    type Owned = Vec<T>;
+impl<T: Clone, const COOP_PREFERRED: bool> ToOwned<COOP_PREFERRED> for [T]
+where
+[(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(
+    COOP_PREFERRED,
+)]:,
+{
+    type Owned = Vec<T, Global, COOP_PREFERRED>;
     #[cfg(not(test))]
-    fn to_owned(&self) -> Vec<T> {
+    fn to_owned(&self) -> Vec<T, Global, COOP_PREFERRED> {
         self.to_vec()
     }
 
     #[cfg(test)]
-    fn to_owned(&self) -> Vec<T> {
+    fn to_owned(&self) -> Vec<T, Global, COOP_PREFERRED> {
         hack::to_vec(self, Global)
     }
 
-    fn clone_into(&self, target: &mut Vec<T>) {
+    fn clone_into(&self, target: &mut Vec<T, Global, COOP_PREFERRED>) {
         // drop anything in target that will not be overwritten
         target.truncate(self.len());
 

library/alloc/src/str.rs

@@ -191,15 +191,21 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl Borrow<str> for String {
+impl<const COOP_PREFERRED: bool> Borrow<str> for String<COOP_PREFERRED>
+where
+    [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
     #[inline]
     fn borrow(&self) -> &str {
         &self[..]
     }
 }
 
 #[stable(feature = "string_borrow_mut", since = "1.36.0")]
-impl BorrowMut<str> for String {
+impl<const COOP_PREFERRED: bool> BorrowMut<str> for String<COOP_PREFERRED>
+where
+    [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
     #[inline]
     fn borrow_mut(&mut self) -> &mut str {
         &mut self[..]

library/alloc/src/string.rs

@@ -3014,7 +3014,7 @@ where
 
 #[cfg(not(no_global_oom_handling))]
 #[stable(feature = "cow_from_string_ref", since = "1.28.0")]
-impl<'a, const COOP_PREFERRED: bool> From<&'a String<COOP_PREFERRED>> for Cow<'a, str>
+impl<'a, const COOP_PREFERRED: bool> From<&'a String<COOP_PREFERRED>> for Cow<'a, str, COOP_PREFERRED>
 where
     [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
 {
@@ -3055,7 +3055,7 @@ impl<'a, 'b> FromIterator<&'b str> for Cow<'a, str> {
 
 #[cfg(not(no_global_oom_handling))]
 #[stable(feature = "cow_str_from_iter", since = "1.12.0")]
-impl<'a, const COOP_PREFERRED: bool> FromIterator<String<COOP_PREFERRED>> for Cow<'a, str>
+impl<'a, const COOP_PREFERRED: bool> FromIterator<String<COOP_PREFERRED>> for Cow<'a, str, COOP_PREFERRED>
 where
     [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
 {

library/alloc/tests/string.rs

@@ -15,7 +15,10 @@ where
     fn into_cow(self) -> Cow<'a, B>;
 }
 
-impl<'a> IntoCow<'a, str> for String {
+impl<'a, const COOP_PREFERRED: bool> IntoCow<'a, str> for String<COOP_PREFERRED>
+where
+    [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
     fn into_cow(self) -> Cow<'a, str> {
         Cow::Owned(self)
     }