Adding COOP_PREFERRED to Cow, ToOwned..

Author: peter-lyons-kehl

library/alloc/src/borrow.rs

@@ -18,9 +18,11 @@ use crate::string::String;
 use Cow::*;
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, B: ?Sized> Borrow<B> for Cow<'a, B>
+impl<'a, B: ?Sized, const COOP_PREFERRED: bool> Borrow<B> for Cow<'a, B, COOP_PREFERRED>
 where
-    B: ToOwned,
+    B: ToOwned<COOP_PREFERRED>,
+    [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+
 {
     fn borrow(&self) -> &B {
         &**self
@@ -83,9 +85,10 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ToOwned for T
+impl<T, const COOP_PREFERRED: bool> ToOwned<COOP_PREFERRED> for T
 where
     T: Clone,
+    [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
 {
     type Owned = T;
     fn to_owned(&self) -> T {
@@ -180,21 +183,26 @@ where
 /// ```
 #[stable(feature = "rust1", since = "1.0.0")]
 #[cfg_attr(not(test), rustc_diagnostic_item = "Cow")]
-pub enum Cow<'a, B: ?Sized + 'a>
+#[allow(unused_braces)]
+pub enum Cow<'a, B: ?Sized + 'a, const COOP_PREFERRED: bool = { DEFAULT_COOP_PREFERRED!() }>
 where
-    B: ToOwned,
+    B: ToOwned<COOP_PREFERRED>,
+    [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
 {
     /// Borrowed data.
     #[stable(feature = "rust1", since = "1.0.0")]
     Borrowed(#[stable(feature = "rust1", since = "1.0.0")] &'a B),
 
     /// Owned data.
     #[stable(feature = "rust1", since = "1.0.0")]
-    Owned(#[stable(feature = "rust1", since = "1.0.0")] <B as ToOwned>::Owned),
+    Owned(#[stable(feature = "rust1", since = "1.0.0")] <B as ToOwned<COOP_PREFERRED>>::Owned),
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<B: ?Sized + ToOwned> Clone for Cow<'_, B> {
+impl<B: ?Sized + ToOwned<COOP_PREFERRED>, const COOP_PREFERRED: bool> Clone for Cow<'_, B, COOP_PREFERRED>
+where
+    [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
     fn clone(&self) -> Self {
         match *self {
             Borrowed(b) => Borrowed(b),
@@ -213,7 +221,10 @@ impl<B: ?Sized + ToOwned> Clone for Cow<'_, B> {
     }
 }
 
-impl<B: ?Sized + ToOwned> Cow<'_, B> {
+impl<B: ?Sized + ToOwned<COOP_PREFERRED>, const COOP_PREFERRED: bool> Cow<'_, B, COOP_PREFERRED>
+where
+[(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
     /// Returns true if the data is borrowed, i.e. if `to_mut` would require additional work.
     ///
     /// # Examples
@@ -275,7 +286,7 @@ impl<B: ?Sized + ToOwned> Cow<'_, B> {
     /// );
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn to_mut(&mut self) -> &mut <B as ToOwned>::Owned {
+    pub fn to_mut(&mut self) -> &mut <B as ToOwned<COOP_PREFERRED>>::Owned {
         match *self {
             Borrowed(borrowed) => {
                 *self = Owned(borrowed.to_owned());
@@ -323,7 +334,7 @@ impl<B: ?Sized + ToOwned> Cow<'_, B> {
     /// );
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn into_owned(self) -> <B as ToOwned>::Owned {
+    pub fn into_owned(self) -> <B as ToOwned<COOP_PREFERRED>>::Owned {
         match self {
             Borrowed(borrowed) => borrowed.to_owned(),
             Owned(owned) => owned,
@@ -385,9 +396,10 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<B: ?Sized> fmt::Debug for Cow<'_, B>
+impl<B: ?Sized, const COOP_PREFERRED: bool> fmt::Debug for Cow<'_, B, COOP_PREFERRED>
 where
-    B: fmt::Debug + ToOwned<Owned: fmt::Debug>,
+    B: fmt::Debug + ToOwned<COOP_PREFERRED, Owned: fmt::Debug>,
+    [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match *self {
@@ -398,9 +410,10 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<B: ?Sized> fmt::Display for Cow<'_, B>
+impl<B: ?Sized, const COOP_PREFERRED: bool> fmt::Display for Cow<'_, B, COOP_PREFERRED>
 where
-    B: fmt::Display + ToOwned<Owned: fmt::Display>,
+    B: fmt::Display + ToOwned<COOP_PREFERRED, Owned: fmt::Display>,
+    [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match *self {
@@ -411,13 +424,14 @@ where
 }
 
 #[stable(feature = "default", since = "1.11.0")]
-impl<B: ?Sized> Default for Cow<'_, B>
+impl<B: ?Sized, const COOP_PREFERRED: bool> Default for Cow<'_, B, COOP_PREFERRED>
 where
-    B: ToOwned<Owned: Default>,
+    B: ToOwned<COOP_PREFERRED, Owned: Default>,
+    [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
 {
     /// Creates an owned Cow<'a, B> with the default value for the contained owned value.
     fn default() -> Self {
-        Owned(<B as ToOwned>::Owned::default())
+        Owned(<B as ToOwned<COOP_PREFERRED>>::Owned::default())
     }
 }
 

library/alloc/src/ffi/c_str.rs

@@ -1102,7 +1102,7 @@ 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> {
+    pub fn to_string_lossy(&self) -> Cow<'_, str, false> {
         // 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())
     }

library/alloc/src/str.rs

@@ -215,13 +215,13 @@ where
     type Owned = String<COOP_PREFERRED>;
     #[inline]
     fn to_owned(&self) -> String<COOP_PREFERRED> {
-        unsafe { String::from_utf8_unchecked(self.as_bytes().to_owned()) }
+        unsafe { String::<COOP_PREFERRED>::from_utf8_unchecked(self.as_bytes().to_owned()) }
     }
 
     fn clone_into(&self, target: &mut String<COOP_PREFERRED>) {
         let mut b = mem::take(target).into_bytes();
         self.as_bytes().clone_into(&mut b);
-        *target = unsafe { String::from_utf8_unchecked(b) }
+        *target = unsafe { String::<COOP_PREFERRED>::from_utf8_unchecked(b) }
     }
 }
 

library/alloc/src/string.rs

@@ -646,7 +646,7 @@ where
     #[must_use]
     #[cfg(not(no_global_oom_handling))]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn from_utf8_lossy(v: &[u8]) -> Cow<'_, str> {
+    pub fn from_utf8_lossy(v: &[u8]) -> Cow<'_, str, COOP_PREFERRED> {
         let mut iter = Utf8Chunks::new(v);
 
         let first_valid = if let Some(chunk) = iter.next() {
@@ -662,7 +662,7 @@ where
 
         const REPLACEMENT: &str = "\u{FFFD}";
 
-        let mut res = String::<false>::with_capacity(v.len());
+        let mut res = String::<COOP_PREFERRED>::with_capacity(v.len());
         res.push_str(first_valid);
         res.push_str(REPLACEMENT);
 
@@ -2132,7 +2132,7 @@ impl<'a, const COOP_PREFERRED: bool> FromIterator<Cow<'a, str>> for String<COOP_
 where
     [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
 {
-    fn from_iter<I: IntoIterator<Item = Cow<'a, str>>>(iter: I) -> String<COOP_PREFERRED> {
+    fn from_iter<I: IntoIterator<Item = Cow<'a, str, COOP_PREFERRED>>>(iter: I) -> String<COOP_PREFERRED> {
         let mut iterator = iter.into_iter();
 
         // Because we're iterating over CoWs, we can (potentially) avoid at least
@@ -2960,7 +2960,7 @@ where
     /// let owned: String = String::from(cow);
     /// assert_eq!(&owned[..], "eggplant");
     /// ```
-    fn from(s: Cow<'a, str>) -> String<COOP_PREFERRED> {
+    fn from(s: Cow<'a, str, COOP_PREFERRED>) -> String<COOP_PREFERRED> {
         s.into_owned()
     }
 }
@@ -3007,7 +3007,7 @@ where
     ///
     /// [`Owned`]: crate::borrow::Cow::Owned "borrow::Cow::Owned"
     #[inline]
-    fn from(s: String<COOP_PREFERRED>) -> Cow<'a, str> {
+    fn from(s: String<COOP_PREFERRED>) -> Cow<'a, str, COOP_PREFERRED> {
         Cow::Owned(s)
     }
 }
@@ -3032,7 +3032,7 @@ where
     ///
     /// [`Borrowed`]: crate::borrow::Cow::Borrowed "borrow::Cow::Borrowed"
     #[inline]
-    fn from(s: &'a String<COOP_PREFERRED>) -> Cow<'a, str> {
+    fn from(s: &'a String<COOP_PREFERRED>) -> Cow<'a, str, COOP_PREFERRED> {
         Cow::Borrowed(s.as_str())
     }
 }
@@ -3059,7 +3059,7 @@ impl<'a, const COOP_PREFERRED: bool> FromIterator<String<COOP_PREFERRED>> for Co
 where
     [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
 {
-    fn from_iter<I: IntoIterator<Item = String<COOP_PREFERRED>>>(it: I) -> Cow<'a, str> {
+    fn from_iter<I: IntoIterator<Item = String<COOP_PREFERRED>>>(it: I) -> Cow<'a, str, COOP_PREFERRED> {
         Cow::Owned(FromIterator::from_iter(it))
     }
 }