Renamed String::from_utf8_lossy_coop_or_not(..) to from_utf8_lossy_co(..). Added Vec::new_co()

Author: peter-lyons-kehl

library/alloc/src/ffi/c_str.rs

@@ -1126,7 +1126,7 @@ impl CStr {
     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::<COOP_PREFERRED>::from_utf8_lossy_coop_or_not(self.to_bytes())
+        String::<COOP_PREFERRED>::from_utf8_lossy_co(self.to_bytes())
     }
 
     /// Converts a <code>[Box]<[CStr]></code> into a [`CString`] without copying or allocating.

library/alloc/src/macros.rs

@@ -41,7 +41,7 @@
 #[allow_internal_unstable(rustc_attrs, liballoc_internals)]
 macro_rules! vec {
     () => (
-        $crate::__rust_force_expr!($crate::vec::Vec::new())
+        $crate::__rust_force_expr!($crate::vec::Vec::new_co())
     );
     ($elem:expr; $n:expr) => (
         $crate::__rust_force_expr!($crate::vec::from_elem($elem, $n))

library/alloc/src/string.rs

@@ -468,7 +468,7 @@ where
     #[stable(feature = "rust1", since = "1.0.0")]
     #[must_use]
     pub const fn new() -> String<COOP_PREFERRED> {
-        String { vec: Vec::new() }
+        String { vec: Vec::new_co() }
     }
 
     /// Creates a new empty `String` with at least the specified capacity.
@@ -595,8 +595,8 @@ where
     }
 
     /// Like `from_utf8_lossy`, but this honors COOP_PREFERRED.
-    #[unstable(feature = "compile_check_struct_with_const_generic_added_associated_function", reason = "confirm_or_fix_the_function_name", issue = "none")]
-    pub fn from_utf8_lossy_coop_or_not(v: &[u8]) -> Cow<'_, str, COOP_PREFERRED> {
+    #[unstable(feature = "string_from_utf8_lossy_co", reason = "confirm_or_fix_the_function_name", issue = "none")]
+    pub fn from_utf8_lossy_co(v: &[u8]) -> Cow<'_, str, COOP_PREFERRED> {
         let mut iter = Utf8Chunks::new(v);
 
         let first_valid = if let Some(chunk) = iter.next() {
@@ -686,7 +686,7 @@ impl String {
     #[stable(feature = "rust1", since = "1.0.0")]
     #[allow(unused_braces)]
     pub fn from_utf8_lossy(v: &[u8]) -> Cow<'_, str, {DEFAULT_COOP_PREFERRED!()}> {
-        String::<{DEFAULT_COOP_PREFERRED!()}>::from_utf8_lossy_coop_or_not(v)
+        String::<{DEFAULT_COOP_PREFERRED!()}>::from_utf8_lossy_co(v)
     }
 }
 

library/alloc/src/vec/mod.rs

@@ -444,14 +444,7 @@ pub type DefVec<T, A = Global> =
 #[unstable(feature = "global_co_alloc_vec", issue = "none")]
 pub type WeVec<T, const WEIGHT: u8> = Vec<T, Global, { WEIGHT > 127 }>;
 
-////////////////////////////////////////////////////////////////////////////////
-// Inherent methods
-////////////////////////////////////////////////////////////////////////////////
-
-impl<T, const COOP_PREFERRED: bool> Vec<T, Global, COOP_PREFERRED>
-where
-    [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
-{
+impl<T> Vec<T> {
     /// Constructs a new, empty `Vec<T>`.
     ///
     /// The vector will not allocate until elements are pushed onto it.
@@ -467,6 +460,25 @@ where
     #[stable(feature = "rust1", since = "1.0.0")]
     #[must_use]
     pub const fn new() -> Self {
+        #[allow(unused_braces)]
+        Vec::<T, Global, {DEFAULT_COOP_PREFERRED!()}>::new_co()
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Inherent methods
+////////////////////////////////////////////////////////////////////////////////
+
+impl<T, const COOP_PREFERRED: bool> Vec<T, Global, COOP_PREFERRED>
+where
+    [(); core::alloc::co_alloc_metadata_num_slots_with_preference::<Global>(COOP_PREFERRED)]:,
+{
+    /// Like new(), but it respects COOP_PREFERRED.
+    #[inline]
+    #[rustc_const_stable(feature = "const_vec_new_co", since = "1.60.0")] //@FIXME This is `rustc_const_stable`, so that String::new() can be const and can call this.
+    #[unstable(feature = "vec_new_co", reason = "confirm_or_fix_the_function_name", issue = "none")]
+    #[must_use]
+    pub const fn new_co() -> Self {
         Vec { buf: RawVec::NEW, len: 0 }
     }
 
@@ -3242,7 +3254,7 @@ where
     ///
     /// The vector will not allocate until elements are pushed onto it.
     fn default() -> Vec<T, Global, COOP_PREFERRED> {
-        Vec::new()
+        Vec::new_co()
     }
 }
 

library/alloc/src/vec/spec_from_iter.rs

@@ -63,7 +63,7 @@ where
             }
         }
 
-        let mut vec = Vec::<T, Global, COOP_PREFERRED>::new();
+        let mut vec = Vec::<T, Global, COOP_PREFERRED>::new_co();
         // must delegate to spec_extend() since extend() itself delegates
         // to spec_from for empty Vecs
         vec.spec_extend(iterator);

library/alloc/src/vec/spec_from_iter_nested.rs

@@ -29,7 +29,7 @@ where
         // vector being full in the few subsequent loop iterations.
         // So we get better branch prediction.
         let mut vector = match iterator.next() {
-            None => return Vec::new(),
+            None => return Vec::new_co(),
             Some(element) => {
                 let (lower, _) = iterator.size_hint();
                 let initial_capacity =