Rename private type os_str::Slice to OsSlice

Author: teor2345

library/std/src/ffi/os_str.rs

@@ -12,7 +12,7 @@ use crate::ops::{self, Range};
 use crate::rc::Rc;
 use crate::str::FromStr;
 use crate::sync::Arc;
-use crate::sys::os_str::{Buf, Slice};
+use crate::sys::os_str::{Buf, OsSlice};
 use crate::sys_common::{AsInner, FromInner, IntoInner};
 use crate::{cmp, fmt, slice};
 
@@ -113,11 +113,11 @@ impl crate::sealed::Sealed for OsString {}
 #[cfg_attr(not(test), rustc_diagnostic_item = "OsStr")]
 #[stable(feature = "rust1", since = "1.0.0")]
 // `OsStr::from_inner` and `impl CloneToUninit for OsStr` current implementation relies
-// on `OsStr` being layout-compatible with `Slice`.
+// on `OsStr` being layout-compatible with `OsSlice`.
 // However, `OsStr` layout is considered an implementation detail and must not be relied upon.
 #[repr(transparent)]
 pub struct OsStr {
-    inner: Slice,
+    inner: OsSlice,
 }
 
 /// Allows extension traits within `std`.
@@ -871,23 +871,23 @@ impl OsStr {
     #[inline]
     #[stable(feature = "os_str_bytes", since = "1.74.0")]
     pub unsafe fn from_encoded_bytes_unchecked(bytes: &[u8]) -> &Self {
-        Self::from_inner(unsafe { Slice::from_encoded_bytes_unchecked(bytes) })
+        Self::from_inner(unsafe { OsSlice::from_encoded_bytes_unchecked(bytes) })
     }
 
     #[inline]
-    fn from_inner(inner: &Slice) -> &OsStr {
-        // SAFETY: OsStr is just a wrapper of Slice,
-        // therefore converting &Slice to &OsStr is safe.
-        unsafe { &*(inner as *const Slice as *const OsStr) }
+    fn from_inner(inner: &OsSlice) -> &OsStr {
+        // SAFETY: OsStr is just a wrapper of OsSlice,
+        // therefore converting &OsSlice to &OsStr is safe.
+        unsafe { &*(inner as *const OsSlice as *const OsStr) }
     }
 
     #[inline]
-    fn from_inner_mut(inner: &mut Slice) -> &mut OsStr {
-        // SAFETY: OsStr is just a wrapper of Slice,
-        // therefore converting &mut Slice to &mut OsStr is safe.
+    fn from_inner_mut(inner: &mut OsSlice) -> &mut OsStr {
+        // SAFETY: OsStr is just a wrapper of OsSlice,
+        // therefore converting &mut OsSlice to &mut OsStr is safe.
         // Any method that mutates OsStr must be careful not to
         // break platform-specific encoding, in particular Wtf8 on Windows.
-        unsafe { &mut *(inner as *mut Slice as *mut OsStr) }
+        unsafe { &mut *(inner as *mut OsSlice as *mut OsStr) }
     }
 
     /// Yields a <code>&[str]</code> slice if the `OsStr` is valid Unicode.
@@ -1041,7 +1041,7 @@ impl OsStr {
     #[stable(feature = "into_boxed_os_str", since = "1.20.0")]
     #[must_use = "`self` will be dropped if the result is not used"]
     pub fn into_os_string(self: Box<OsStr>) -> OsString {
-        let boxed = unsafe { Box::from_raw(Box::into_raw(self) as *mut Slice) };
+        let boxed = unsafe { Box::from_raw(Box::into_raw(self) as *mut OsSlice) };
         OsString { inner: Buf::from_box(boxed) }
     }
 
@@ -1338,7 +1338,7 @@ unsafe impl CloneToUninit for OsStr {
     #[inline]
     #[cfg_attr(debug_assertions, track_caller)]
     unsafe fn clone_to_uninit(&self, dst: *mut u8) {
-        // SAFETY: we're just a transparent wrapper around a platform-specific Slice
+        // SAFETY: we're just a transparent wrapper around a platform-specific OsSlice
         unsafe { self.inner.clone_to_uninit(dst) }
     }
 }
@@ -1462,7 +1462,7 @@ impl<'a> TryFrom<&'a OsStr> for &'a str {
 impl Default for Box<OsStr> {
     #[inline]
     fn default() -> Box<OsStr> {
-        let rw = Box::into_raw(Slice::empty_box()) as *mut OsStr;
+        let rw = Box::into_raw(OsSlice::empty_box()) as *mut OsStr;
         unsafe { Box::from_raw(rw) }
     }
 }
@@ -1699,7 +1699,7 @@ impl AsRef<OsStr> for OsString {
 impl AsRef<OsStr> for str {
     #[inline]
     fn as_ref(&self) -> &OsStr {
-        OsStr::from_inner(Slice::from_str(self))
+        OsStr::from_inner(OsSlice::from_str(self))
     }
 }
 
@@ -1725,9 +1725,9 @@ impl IntoInner<Buf> for OsString {
     }
 }
 
-impl AsInner<Slice> for OsStr {
+impl AsInner<OsSlice> for OsStr {
     #[inline]
-    fn as_inner(&self) -> &Slice {
+    fn as_inner(&self) -> &OsSlice {
         &self.inner
     }
 }

library/std/src/sys/os_str/bytes.rs

@@ -21,7 +21,7 @@ pub struct Buf {
 }
 
 #[repr(transparent)]
-pub struct Slice {
+pub struct OsSlice {
     pub inner: [u8],
 }
 
@@ -56,13 +56,13 @@ impl fmt::Display for Buf {
     }
 }
 
-impl fmt::Debug for Slice {
+impl fmt::Debug for OsSlice {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Debug::fmt(&self.inner.utf8_chunks().debug(), f)
     }
 }
 
-impl fmt::Display for Slice {
+impl fmt::Display for OsSlice {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         // If we're the empty string then our iterator won't actually yield
         // anything, so perform the formatting manually
@@ -135,7 +135,7 @@ impl Buf {
     }
 
     #[inline]
-    pub fn push_slice(&mut self, s: &Slice) {
+    pub fn push_slice(&mut self, s: &OsSlice) {
         self.inner.extend_from_slice(&s.inner)
     }
 
@@ -175,44 +175,44 @@ impl Buf {
     }
 
     #[inline]
-    pub fn as_slice(&self) -> &Slice {
-        // SAFETY: Slice just wraps [u8],
+    pub fn as_slice(&self) -> &OsSlice {
+        // SAFETY: OsSlice just wraps [u8],
         // and &*self.inner is &[u8], therefore
-        // transmuting &[u8] to &Slice is safe.
+        // transmuting &[u8] to &OsSlice is safe.
         unsafe { mem::transmute(self.inner.as_slice()) }
     }
 
     #[inline]
-    pub fn as_mut_slice(&mut self) -> &mut Slice {
-        // SAFETY: Slice just wraps [u8],
+    pub fn as_mut_slice(&mut self) -> &mut OsSlice {
+        // SAFETY: OsSlice just wraps [u8],
         // and &mut *self.inner is &mut [u8], therefore
-        // transmuting &mut [u8] to &mut Slice is safe.
+        // transmuting &mut [u8] to &mut OsSlice is safe.
         unsafe { mem::transmute(self.inner.as_mut_slice()) }
     }
 
     #[inline]
-    pub fn leak<'a>(self) -> &'a mut Slice {
+    pub fn leak<'a>(self) -> &'a mut OsSlice {
         unsafe { mem::transmute(self.inner.leak()) }
     }
 
     #[inline]
-    pub fn into_box(self) -> Box<Slice> {
+    pub fn into_box(self) -> Box<OsSlice> {
         unsafe { mem::transmute(self.inner.into_boxed_slice()) }
     }
 
     #[inline]
-    pub fn from_box(boxed: Box<Slice>) -> Buf {
+    pub fn from_box(boxed: Box<OsSlice>) -> Buf {
         let inner: Box<[u8]> = unsafe { mem::transmute(boxed) };
         Buf { inner: inner.into_vec() }
     }
 
     #[inline]
-    pub fn into_arc(&self) -> Arc<Slice> {
+    pub fn into_arc(&self) -> Arc<OsSlice> {
         self.as_slice().into_arc()
     }
 
     #[inline]
-    pub fn into_rc(&self) -> Rc<Slice> {
+    pub fn into_rc(&self) -> Rc<OsSlice> {
         self.as_slice().into_rc()
     }
 
@@ -222,7 +222,7 @@ impl Buf {
     /// # Safety
     ///
     /// The length must be at an `OsStr` boundary, according to
-    /// `Slice::check_public_boundary`.
+    /// `OsSlice::check_public_boundary`.
     #[inline]
     pub unsafe fn truncate_unchecked(&mut self, len: usize) {
         self.inner.truncate(len);
@@ -240,14 +240,14 @@ impl Buf {
     }
 }
 
-impl Slice {
+impl OsSlice {
     #[inline]
     pub fn as_encoded_bytes(&self) -> &[u8] {
         &self.inner
     }
 
     #[inline]
-    pub unsafe fn from_encoded_bytes_unchecked(s: &[u8]) -> &Slice {
+    pub unsafe fn from_encoded_bytes_unchecked(s: &[u8]) -> &OsSlice {
         unsafe { mem::transmute(s) }
     }
 
@@ -295,8 +295,8 @@ impl Slice {
     }
 
     #[inline]
-    pub fn from_str(s: &str) -> &Slice {
-        unsafe { Slice::from_encoded_bytes_unchecked(s.as_bytes()) }
+    pub fn from_str(s: &str) -> &OsSlice {
+        unsafe { OsSlice::from_encoded_bytes_unchecked(s.as_bytes()) }
     }
 
     #[inline]
@@ -320,27 +320,27 @@ impl Slice {
     }
 
     #[inline]
-    pub fn into_box(&self) -> Box<Slice> {
+    pub fn into_box(&self) -> Box<OsSlice> {
         let boxed: Box<[u8]> = self.inner.into();
         unsafe { mem::transmute(boxed) }
     }
 
     #[inline]
-    pub fn empty_box() -> Box<Slice> {
+    pub fn empty_box() -> Box<OsSlice> {
         let boxed: Box<[u8]> = Default::default();
         unsafe { mem::transmute(boxed) }
     }
 
     #[inline]
-    pub fn into_arc(&self) -> Arc<Slice> {
+    pub fn into_arc(&self) -> Arc<OsSlice> {
         let arc: Arc<[u8]> = Arc::from(&self.inner);
-        unsafe { Arc::from_raw(Arc::into_raw(arc) as *const Slice) }
+        unsafe { Arc::from_raw(Arc::into_raw(arc) as *const OsSlice) }
     }
 
     #[inline]
-    pub fn into_rc(&self) -> Rc<Slice> {
+    pub fn into_rc(&self) -> Rc<OsSlice> {
         let rc: Rc<[u8]> = Rc::from(&self.inner);
-        unsafe { Rc::from_raw(Rc::into_raw(rc) as *const Slice) }
+        unsafe { Rc::from_raw(Rc::into_raw(rc) as *const OsSlice) }
     }
 
     #[inline]
@@ -375,7 +375,7 @@ impl Slice {
 }
 
 #[unstable(feature = "clone_to_uninit", issue = "126799")]
-unsafe impl CloneToUninit for Slice {
+unsafe impl CloneToUninit for OsSlice {
     #[inline]
     #[cfg_attr(debug_assertions, track_caller)]
     unsafe fn clone_to_uninit(&self, dst: *mut u8) {

library/std/src/sys/os_str/bytes/tests.rs

@@ -2,7 +2,7 @@ use super::*;
 
 #[test]
 fn slice_debug_output() {
-    let input = unsafe { Slice::from_encoded_bytes_unchecked(b"\xF0hello,\tworld") };
+    let input = unsafe { OsSlice::from_encoded_bytes_unchecked(b"\xF0hello,\tworld") };
     let expected = r#""\xF0hello,\tworld""#;
     let output = format!("{input:?}");
 
@@ -12,6 +12,6 @@ fn slice_debug_output() {
 #[test]
 fn display() {
     assert_eq!("Hello\u{FFFD}\u{FFFD} There\u{FFFD} Goodbye", unsafe {
-        Slice::from_encoded_bytes_unchecked(b"Hello\xC0\x80 There\xE6\x83 Goodbye").to_string()
+        OsSlice::from_encoded_bytes_unchecked(b"Hello\xC0\x80 There\xE6\x83 Goodbye").to_string()
     },);
 }

library/std/src/sys/os_str/mod.rs

@@ -6,9 +6,9 @@ cfg_if::cfg_if! {
         target_os = "uefi",
     ))] {
         mod wtf8;
-        pub use wtf8::{Buf, Slice};
+        pub use wtf8::{Buf, OsSlice};
     } else {
         mod bytes;
-        pub use bytes::{Buf, Slice};
+        pub use bytes::{Buf, OsSlice};
     }
 }