str

Author: Robert Bastian

compiler/rustc_feature/src/unstable.rs

@@ -497,6 +497,8 @@ declare_features! (
     (unstable, impl_trait_in_fn_trait_return, "1.64.0", Some(99697)),
     /// Allows associated types in inherent impls.
     (incomplete, inherent_associated_types, "1.52.0", Some(8995)),
+    /// Adds `from_utf8*` functions as inherent methods on the `str` type.
+    (unstable, inherent_str_constructors, "1.82.0", Some(131114)),
     /// Allow anonymous constants from an inline `const` block in pattern position
     (unstable, inline_const_pat, "1.58.0", Some(76001)),
     /// Allows using `pointer` and `reference` in intra-doc links

compiler/rustc_span/src/symbol.rs

@@ -1067,6 +1067,7 @@ symbols! {
         infer_outlives_requirements,
         infer_static_outlives_requirements,
         inherent_associated_types,
+        inherent_str_constructors,
         inherit,
         inlateout,
         inline,

library/alloc/src/lib.rs

@@ -127,6 +127,7 @@
 #![feature(fmt_internals)]
 #![feature(fn_traits)]
 #![feature(hasher_prefixfree_extras)]
+#![feature(inherent_str_constructors)]
 #![feature(inplace_iteration)]
 #![feature(iter_advance_by)]
 #![feature(iter_next_chunk)]

library/alloc/src/str.rs

@@ -12,6 +12,8 @@ use core::iter::FusedIterator;
 use core::mem::MaybeUninit;
 #[stable(feature = "encode_utf16", since = "1.8.0")]
 pub use core::str::EncodeUtf16;
+#[stable(feature = "rust1", since = "1.0.0")]
+pub use core::str::ParseBoolError;
 #[stable(feature = "split_ascii_whitespace", since = "1.34.0")]
 pub use core::str::SplitAsciiWhitespace;
 #[stable(feature = "split_inclusive", since = "1.51.0")]
@@ -22,7 +24,7 @@ pub use core::str::SplitWhitespace;
 pub use core::str::pattern;
 use core::str::pattern::{DoubleEndedSearcher, Pattern, ReverseSearcher, Searcher};
 #[stable(feature = "rust1", since = "1.0.0")]
-pub use core::str::{Bytes, CharIndices, Chars, from_utf8, from_utf8_mut};
+pub use core::str::{Bytes, CharIndices, Chars};
 #[stable(feature = "str_escape", since = "1.34.0")]
 pub use core::str::{EscapeDebug, EscapeDefault, EscapeUnicode};
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -35,8 +37,6 @@ pub use core::str::{MatchIndices, RMatchIndices};
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use core::str::{Matches, RMatches};
 #[stable(feature = "rust1", since = "1.0.0")]
-pub use core::str::{ParseBoolError, from_utf8_unchecked, from_utf8_unchecked_mut};
-#[stable(feature = "rust1", since = "1.0.0")]
 pub use core::str::{RSplit, Split};
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use core::str::{RSplitN, SplitN};
@@ -46,6 +46,9 @@ pub use core::str::{RSplitTerminator, SplitTerminator};
 pub use core::str::{Utf8Chunk, Utf8Chunks};
 #[unstable(feature = "str_from_raw_parts", issue = "119206")]
 pub use core::str::{from_raw_parts, from_raw_parts_mut};
+#[allow(deprecated_in_future)]
+#[stable(feature = "rust1", since = "1.0.0")]
+pub use core::str::{from_utf8, from_utf8_mut, from_utf8_unchecked, from_utf8_unchecked_mut};
 use core::unicode::conversions;
 use core::{mem, ptr};
 
@@ -681,7 +684,7 @@ pub fn convert_while_ascii(s: &str, convert: fn(&u8) -> u8) -> (String, &str) {
 
         // SAFETY: we know this is a valid char boundary
         // since we only skipped over leading ascii bytes
-        let rest = core::str::from_utf8_unchecked(slice);
+        let rest = str::from_utf8_unchecked(slice);
 
         (ascii_string, rest)
     }

library/alloc/src/string.rs

@@ -62,7 +62,7 @@ use crate::alloc::Allocator;
 use crate::borrow::{Cow, ToOwned};
 use crate::boxed::Box;
 use crate::collections::TryReserveError;
-use crate::str::{self, Chars, Utf8Error, from_utf8_unchecked_mut};
+use crate::str::{Chars, Utf8Error};
 #[cfg(not(no_global_oom_handling))]
 use crate::str::{FromStr, from_boxed_utf8_unchecked};
 use crate::vec::Vec;
@@ -2055,7 +2055,7 @@ impl String {
     #[inline]
     pub fn leak<'a>(self) -> &'a mut str {
         let slice = self.vec.leak();
-        unsafe { from_utf8_unchecked_mut(slice) }
+        unsafe { str::from_utf8_unchecked_mut(slice) }
     }
 }
 

library/alloc/src/sync.rs

@@ -3482,7 +3482,7 @@ impl Default for Arc<str> {
     #[inline]
     fn default() -> Self {
         let arc: Arc<[u8]> = Default::default();
-        debug_assert!(core::str::from_utf8(&*arc).is_ok());
+        debug_assert!(str::from_utf8(&*arc).is_ok());
         let (ptr, alloc) = Arc::into_inner_with_allocator(arc);
         unsafe { Arc::from_ptr_in(ptr.as_ptr() as *mut ArcInner<str>, alloc) }
     }

library/core/src/char/methods.rs

@@ -3,7 +3,6 @@
 use super::*;
 use crate::intrinsics::const_eval_select;
 use crate::slice;
-use crate::str::from_utf8_unchecked_mut;
 use crate::unicode::printable::is_printable;
 use crate::unicode::{self, conversions};
 
@@ -678,7 +677,7 @@ impl char {
     #[inline]
     pub const fn encode_utf8(self, dst: &mut [u8]) -> &mut str {
         // SAFETY: `char` is not a surrogate, so this is valid UTF-8.
-        unsafe { from_utf8_unchecked_mut(encode_utf8_raw(self as u32, dst)) }
+        unsafe { str::from_utf8_unchecked_mut(encode_utf8_raw(self as u32, dst)) }
     }
 
     /// Encodes this character as UTF-16 into the provided `u16` buffer,

library/core/src/ffi/c_str.rs

@@ -7,7 +7,7 @@ use crate::iter::FusedIterator;
 use crate::marker::PhantomData;
 use crate::ptr::NonNull;
 use crate::slice::memchr;
-use crate::{fmt, intrinsics, ops, slice, str};
+use crate::{fmt, intrinsics, ops, slice};
 
 // FIXME: because this is doc(inline)d, we *have* to use intra-doc links because the actual link
 //   depends on where the item is being documented. however, since this is libcore, we can't
@@ -664,7 +664,7 @@ impl CStr {
     /// ```
     #[stable(feature = "cstr_to_str", since = "1.4.0")]
     #[rustc_const_stable(feature = "const_cstr_methods", since = "1.72.0")]
-    pub const fn to_str(&self) -> Result<&str, str::Utf8Error> {
+    pub const fn to_str(&self) -> Result<&str, crate::str::Utf8Error> {
         // N.B., when `CStr` is changed to perform the length check in `.to_bytes()`
         // instead of in `from_ptr()`, it may be worth considering if this should
         // be rewritten to do the UTF-8 check inline with the length calculation

library/core/src/fmt/mod.rs

@@ -7,7 +7,7 @@ use crate::char::EscapeDebugExtArgs;
 use crate::marker::PhantomData;
 use crate::num::fmt as numfmt;
 use crate::ops::Deref;
-use crate::{iter, mem, result, str};
+use crate::{iter, mem, result};
 
 mod builders;
 #[cfg(not(no_fp_fmt_parse))]

library/core/src/fmt/num.rs

@@ -3,7 +3,7 @@
 use crate::mem::MaybeUninit;
 use crate::num::fmt as numfmt;
 use crate::ops::{Div, Rem, Sub};
-use crate::{fmt, ptr, slice, str};
+use crate::{fmt, ptr, slice};
 
 #[doc(hidden)]
 trait DisplayInt:

library/core/src/net/display_buffer.rs

@@ -1,5 +1,5 @@
+use crate::fmt;
 use crate::mem::MaybeUninit;
-use crate::{fmt, str};
 
 /// Used for slow path in `Display` implementations when alignment is required.
 pub struct DisplayBuffer<const SIZE: usize> {

library/core/src/slice/ascii.rs

@@ -280,7 +280,7 @@ impl<'a> fmt::Display for EscapeAscii<'a> {
             // SAFETY: prefix length was derived by counting bytes in the same splice, so it's in-bounds
             let (prefix, remainder) = unsafe { bytes.split_at_unchecked(prefix) };
             // SAFETY: prefix is a valid utf8 sequence, as it's a subset of ASCII
-            let prefix = unsafe { crate::str::from_utf8_unchecked(prefix) };
+            let prefix = unsafe { str::from_utf8_unchecked(prefix) };
 
             f.write_str(prefix)?; // the fast part
 

library/core/src/str/converts.rs

@@ -1,8 +1,7 @@
 //! Ways to create a `str` from bytes slice.
 
 use super::Utf8Error;
-use super::validations::run_utf8_validation;
-use crate::{mem, ptr};
+use crate::ptr;
 
 /// Converts a slice of bytes to a string slice.
 ///
@@ -83,16 +82,10 @@ use crate::{mem, ptr};
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_const_stable(feature = "const_str_from_utf8_shared", since = "1.63.0")]
 #[rustc_allow_const_fn_unstable(str_internals)]
-#[rustc_diagnostic_item = "str_from_utf8"]
+#[deprecated(since = "TBD", note = "replaced by the `from_utf8` method on the `str` type")]
+// #[rustc_diagnostic_item = "str_from_utf8"]
 pub const fn from_utf8(v: &[u8]) -> Result<&str, Utf8Error> {
-    // FIXME(const-hack): This should use `?` again, once it's `const`
-    match run_utf8_validation(v) {
-        Ok(_) => {
-            // SAFETY: validation succeeded.
-            Ok(unsafe { from_utf8_unchecked(v) })
-        }
-        Err(err) => Err(err),
-    }
+    str::from_utf8(v)
 }
 
 /// Converts a mutable slice of bytes to a mutable string slice.
@@ -127,13 +120,14 @@ pub const fn from_utf8(v: &[u8]) -> Result<&str, Utf8Error> {
 /// errors that can be returned.
 #[stable(feature = "str_mut_extras", since = "1.20.0")]
 #[rustc_const_unstable(feature = "const_str_from_utf8", issue = "91006")]
-#[rustc_diagnostic_item = "str_from_utf8_mut"]
+#[deprecated(since = "TBD", note = "replaced by the `from_utf8_mut` method on the `str` type")]
+// #[rustc_diagnostic_item = "str_from_utf8_mut"]
 pub const fn from_utf8_mut(v: &mut [u8]) -> Result<&mut str, Utf8Error> {
     // FIXME(const-hack): This should use `?` again, once it's `const`
-    match run_utf8_validation(v) {
+    match super::run_utf8_validation(v) {
         Ok(_) => {
             // SAFETY: validation succeeded.
-            Ok(unsafe { from_utf8_unchecked_mut(v) })
+            Ok(unsafe { str::from_utf8_unchecked_mut(v) })
         }
         Err(err) => Err(err),
     }
@@ -168,11 +162,14 @@ pub const fn from_utf8_mut(v: &mut [u8]) -> Result<&mut str, Utf8Error> {
 #[must_use]
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_const_stable(feature = "const_str_from_utf8_unchecked", since = "1.55.0")]
-#[rustc_diagnostic_item = "str_from_utf8_unchecked"]
+#[deprecated(
+    since = "TBD",
+    note = "replaced by the `from_utf8_unchecked` method on the `str` type"
+)]
+// #[rustc_diagnostic_item = "str_from_utf8_unchecked"]
 pub const unsafe fn from_utf8_unchecked(v: &[u8]) -> &str {
-    // SAFETY: the caller must guarantee that the bytes `v` are valid UTF-8.
-    // Also relies on `&str` and `&[u8]` having the same layout.
-    unsafe { mem::transmute(v) }
+    // SAFETY: same requirements
+    unsafe { str::from_utf8_unchecked(v) }
 }
 
 /// Converts a slice of bytes to a string slice without checking
@@ -200,13 +197,14 @@ pub const unsafe fn from_utf8_unchecked(v: &[u8]) -> &str {
     feature = "const_str_from_utf8_unchecked_mut",
     since = "CURRENT_RUSTC_VERSION"
 )]
-#[rustc_diagnostic_item = "str_from_utf8_unchecked_mut"]
+#[deprecated(
+    since = "TBD",
+    note = "replaced by the `from_utf8_unchecked_mut` method on the `str` type"
+)]
+// #[rustc_diagnostic_item = "str_from_utf8_unchecked_mut"]
 pub const unsafe fn from_utf8_unchecked_mut(v: &mut [u8]) -> &mut str {
-    // SAFETY: the caller must guarantee that the bytes `v`
-    // are valid UTF-8, thus the cast to `*mut str` is safe.
-    // Also, the pointer dereference is safe because that pointer
-    // comes from a reference which is guaranteed to be valid for writes.
-    unsafe { &mut *(v as *mut [u8] as *mut str) }
+    // SAFETY: same requirements
+    unsafe { str::from_utf8_unchecked_mut(v) }
 }
 
 /// Creates a `&str` from a pointer and a length.

library/core/src/str/iter.rs

@@ -4,7 +4,7 @@ use super::pattern::{DoubleEndedSearcher, Pattern, ReverseSearcher, Searcher};
 use super::validations::{next_code_point, next_code_point_reverse};
 use super::{
     BytesIsNotEmpty, CharEscapeDebugContinue, CharEscapeDefault, CharEscapeUnicode,
-    IsAsciiWhitespace, IsNotEmpty, IsWhitespace, LinesMap, UnsafeBytesToStr, from_utf8_unchecked,
+    IsAsciiWhitespace, IsNotEmpty, IsWhitespace, LinesMap, UnsafeBytesToStr,
 };
 use crate::fmt::{self, Write};
 use crate::iter::{
@@ -158,7 +158,7 @@ impl<'a> Chars<'a> {
     #[inline]
     pub fn as_str(&self) -> &'a str {
         // SAFETY: `Chars` is only made from a str, which guarantees the iter is valid UTF-8.
-        unsafe { from_utf8_unchecked(self.iter.as_slice()) }
+        unsafe { str::from_utf8_unchecked(self.iter.as_slice()) }
     }
 }
 
@@ -1413,7 +1413,7 @@ impl<'a> SplitAsciiWhitespace<'a> {
         }
 
         // SAFETY: Slice is created from str.
-        Some(unsafe { crate::str::from_utf8_unchecked(&self.inner.iter.iter.v) })
+        Some(unsafe { str::from_utf8_unchecked(&self.inner.iter.iter.v) })
     }
 }
 

library/core/src/str/lossy.rs

@@ -1,4 +1,3 @@
-use super::from_utf8_unchecked;
 use super::validations::utf8_char_width;
 use crate::fmt;
 use crate::fmt::{Formatter, Write};
@@ -281,7 +280,7 @@ impl<'a> Iterator for Utf8Chunks<'a> {
 
         Some(Utf8Chunk {
             // SAFETY: All bytes up to `valid_up_to` are valid UTF-8.
-            valid: unsafe { from_utf8_unchecked(valid) },
+            valid: unsafe { str::from_utf8_unchecked(valid) },
             invalid,
         })
     }