mv std libs to library/

3 files changed, 0 insertions, 3333 deletions

diff --git a/src/libstd/ffi/c_str.rs b/src/libstd/ffi/c_str.rs
deleted file mode 100644
index da25a0ede72..00000000000
--- a/src/libstd/ffi/c_str.rs
+++ /dev/null
@@ -1,1788 +0,0 @@
-use crate::ascii;
-use crate::borrow::{Borrow, Cow};
-use crate::cmp::Ordering;
-use crate::error::Error;
-use crate::fmt::{self, Write};
-use crate::io;
-use crate::mem;
-use crate::memchr;
-use crate::num::NonZeroU8;
-use crate::ops;
-use crate::os::raw::c_char;
-use crate::ptr;
-use crate::rc::Rc;
-use crate::slice;
-use crate::str::{self, Utf8Error};
-use crate::sync::Arc;
-use crate::sys;
-
-/// A type representing an owned, C-compatible, nul-terminated string with no nul bytes in the
-/// middle.
-///
-/// This type serves the purpose of being able to safely generate a
-/// C-compatible string from a Rust byte slice or vector. An instance of this
-/// type is a static guarantee that the underlying bytes contain no interior 0
-/// bytes ("nul characters") and that the final byte is 0 ("nul terminator").
-///
-/// `CString` is to [`&CStr`] as [`String`] is to [`&str`]: the former
-/// in each pair are owned strings; the latter are borrowed
-/// references.
-///
-/// # Creating a `CString`
-///
-/// A `CString` is created from either a byte slice or a byte vector,
-/// or anything that implements [`Into`]`<`[`Vec`]`<`[`u8`]`>>` (for
-/// example, you can build a `CString` straight out of a [`String`] or
-/// a [`&str`], since both implement that trait).
-///
-/// The [`new`] method will actually check that the provided `&[u8]`
-/// does not have 0 bytes in the middle, and return an error if it
-/// finds one.
-///
-/// # Extracting a raw pointer to the whole C string
-///
-/// `CString` implements a [`as_ptr`] method through the [`Deref`]
-/// trait. This method will give you a `*const c_char` which you can
-/// feed directly to extern functions that expect a nul-terminated
-/// string, like C's `strdup()`. Notice that [`as_ptr`] returns a
-/// read-only pointer; if the C code writes to it, that causes
-/// undefined behavior.
-///
-/// # Extracting a slice of the whole C string
-///
-/// Alternatively, you can obtain a `&[`[`u8`]`]` slice from a
-/// `CString` with the [`as_bytes`] method. Slices produced in this
-/// way do *not* contain the trailing nul terminator. This is useful
-/// when you will be calling an extern function that takes a `*const
-/// u8` argument which is not necessarily nul-terminated, plus another
-/// argument with the length of the string — like C's `strndup()`.
-/// You can of course get the slice's length with its
-/// [`len`][slice.len] method.
-///
-/// If you need a `&[`[`u8`]`]` slice *with* the nul terminator, you
-/// can use [`as_bytes_with_nul`] instead.
-///
-/// Once you have the kind of slice you need (with or without a nul
-/// terminator), you can call the slice's own
-/// [`as_ptr`][slice.as_ptr] method to get a read-only raw pointer to pass to
-/// extern functions. See the documentation for that function for a
-/// discussion on ensuring the lifetime of the raw pointer.
-///
-/// [`Into`]: ../convert/trait.Into.html
-/// [`Vec`]: ../vec/struct.Vec.html
-/// [`String`]: ../string/struct.String.html
-/// [`&str`]: ../primitive.str.html
-/// [`u8`]: ../primitive.u8.html
-/// [`new`]: #method.new
-/// [`as_bytes`]: #method.as_bytes
-/// [`as_bytes_with_nul`]: #method.as_bytes_with_nul
-/// [`as_ptr`]: #method.as_ptr
-/// [slice.as_ptr]: ../primitive.slice.html#method.as_ptr
-/// [slice.len]: ../primitive.slice.html#method.len
-/// [`Deref`]: ../ops/trait.Deref.html
-/// [`CStr`]: struct.CStr.html
-/// [`&CStr`]: struct.CStr.html
-///
-/// # Examples
-///
-/// ```ignore (extern-declaration)
-/// # fn main() {
-/// use std::ffi::CString;
-/// use std::os::raw::c_char;
-///
-/// extern {
-///     fn my_printer(s: *const c_char);
-/// }
-///
-/// // We are certain that our string doesn't have 0 bytes in the middle,
-/// // so we can .expect()
-/// let c_to_print = CString::new("Hello, world!").expect("CString::new failed");
-/// unsafe {
-///     my_printer(c_to_print.as_ptr());
-/// }
-/// # }
-/// ```
-///
-/// # Safety
-///
-/// `CString` is intended for working with traditional C-style strings
-/// (a sequence of non-nul bytes terminated by a single nul byte); the
-/// primary use case for these kinds of strings is interoperating with C-like
-/// code. Often you will need to transfer ownership to/from that external
-/// code. It is strongly recommended that you thoroughly read through the
-/// documentation of `CString` before use, as improper ownership management
-/// of `CString` instances can lead to invalid memory accesses, memory leaks,
-/// and other memory errors.
-
-#[derive(PartialEq, PartialOrd, Eq, Ord, Hash, Clone)]
-#[stable(feature = "rust1", since = "1.0.0")]
-pub struct CString {
-    // Invariant 1: the slice ends with a zero byte and has a length of at least one.
-    // Invariant 2: the slice contains only one zero byte.
-    // Improper usage of unsafe function can break Invariant 2, but not Invariant 1.
-    inner: Box<[u8]>,
-}
-
-/// Representation of a borrowed C string.
-///
-/// This type represents a borrowed reference to a nul-terminated
-/// array of bytes. It can be constructed safely from a `&[`[`u8`]`]`
-/// slice, or unsafely from a raw `*const c_char`. It can then be
-/// converted to a Rust [`&str`] by performing UTF-8 validation, or
-/// into an owned [`CString`].
-///
-/// `&CStr` is to [`CString`] as [`&str`] is to [`String`]: the former
-/// in each pair are borrowed references; the latter are owned
-/// strings.
-///
-/// Note that this structure is **not** `repr(C)` and is not recommended to be
-/// placed in the signatures of FFI functions. Instead, safe wrappers of FFI
-/// functions may leverage the unsafe [`from_ptr`] constructor to provide a safe
-/// interface to other consumers.
-///
-/// # Examples
-///
-/// Inspecting a foreign C string:
-///
-/// ```ignore (extern-declaration)
-/// use std::ffi::CStr;
-/// use std::os::raw::c_char;
-///
-/// extern { fn my_string() -> *const c_char; }
-///
-/// unsafe {
-///     let slice = CStr::from_ptr(my_string());
-///     println!("string buffer size without nul terminator: {}", slice.to_bytes().len());
-/// }
-/// ```
-///
-/// Passing a Rust-originating C string:
-///
-/// ```ignore (extern-declaration)
-/// use std::ffi::{CString, CStr};
-/// use std::os::raw::c_char;
-///
-/// fn work(data: &CStr) {
-///     extern { fn work_with(data: *const c_char); }
-///
-///     unsafe { work_with(data.as_ptr()) }
-/// }
-///
-/// let s = CString::new("data data data data").expect("CString::new failed");
-/// work(&s);
-/// ```
-///
-/// Converting a foreign C string into a Rust [`String`]:
-///
-/// ```ignore (extern-declaration)
-/// use std::ffi::CStr;
-/// use std::os::raw::c_char;
-///
-/// extern { fn my_string() -> *const c_char; }
-///
-/// fn my_string_safe() -> String {
-///     unsafe {
-///         CStr::from_ptr(my_string()).to_string_lossy().into_owned()
-///     }
-/// }
-///
-/// println!("string: {}", my_string_safe());
-/// ```
-///
-/// [`u8`]: ../primitive.u8.html
-/// [`&str`]: ../primitive.str.html
-/// [`String`]: ../string/struct.String.html
-/// [`CString`]: struct.CString.html
-/// [`from_ptr`]: #method.from_ptr
-#[derive(Hash)]
-#[stable(feature = "rust1", since = "1.0.0")]
-// FIXME:
-// `fn from` in `impl From<&CStr> for Box<CStr>` current implementation relies
-// on `CStr` being layout-compatible with `[u8]`.
-// When attribute privacy is implemented, `CStr` should be annotated as `#[repr(transparent)]`.
-// Anyway, `CStr` representation and layout are considered implementation detail, are
-// not documented and must not be relied upon.
-pub struct CStr {
-    // FIXME: this should not be represented with a DST slice but rather with
-    //        just a raw `c_char` along with some form of marker to make
-    //        this an unsized type. Essentially `sizeof(&CStr)` should be the
-    //        same as `sizeof(&c_char)` but `CStr` should be an unsized type.
-    inner: [c_char],
-}
-
-/// An error indicating that an interior nul byte was found.
-///
-/// While Rust strings may contain nul bytes in the middle, C strings
-/// can't, as that byte would effectively truncate the string.
-///
-/// This error is created by the [`new`][`CString::new`] method on
-/// [`CString`]. See its documentation for more.
-///
-/// [`CString`]: struct.CString.html
-/// [`CString::new`]: struct.CString.html#method.new
-///
-/// # Examples
-///
-/// ```
-/// use std::ffi::{CString, NulError};
-///
-/// let _: NulError = CString::new(b"f\0oo".to_vec()).unwrap_err();
-/// ```
-#[derive(Clone, PartialEq, Eq, Debug)]
-#[stable(feature = "rust1", since = "1.0.0")]
-pub struct NulError(usize, Vec<u8>);
-
-/// An error indicating that a nul byte was not in the expected position.
-///
-/// The slice used to create a [`CStr`] must have one and only one nul byte,
-/// positioned at the end.
-///
-/// This error is created by the [`from_bytes_with_nul`] method on [`CStr`].
-/// See its documentation for more.
-///
-/// [`CStr`]: struct.CStr.html
-/// [`from_bytes_with_nul`]: struct.CStr.html#method.from_bytes_with_nul
-///
-/// # Examples
-///
-/// ```
-/// use std::ffi::{CStr, FromBytesWithNulError};
-///
-/// let _: FromBytesWithNulError = CStr::from_bytes_with_nul(b"f\0oo").unwrap_err();
-/// ```
-#[derive(Clone, PartialEq, Eq, Debug)]
-#[stable(feature = "cstr_from_bytes", since = "1.10.0")]
-pub struct FromBytesWithNulError {
-    kind: FromBytesWithNulErrorKind,
-}
-
-/// An error indicating that a nul byte was not in the expected position.
-///
-/// The vector used to create a [`CString`] must have one and only one nul byte,
-/// positioned at the end.
-///
-/// This error is created by the [`from_vec_with_nul`] method on [`CString`].
-/// See its documentation for more.
-///
-/// [`CString`]: struct.CString.html
-/// [`from_vec_with_nul`]: struct.CString.html#method.from_vec_with_nul
-///
-/// # Examples
-///
-/// ```
-/// #![feature(cstring_from_vec_with_nul)]
-/// use std::ffi::{CString, FromVecWithNulError};
-///
-/// let _: FromVecWithNulError = CString::from_vec_with_nul(b"f\0oo".to_vec()).unwrap_err();
-/// ```
-#[derive(Clone, PartialEq, Eq, Debug)]
-#[unstable(feature = "cstring_from_vec_with_nul", issue = "73179")]
-pub struct FromVecWithNulError {
-    error_kind: FromBytesWithNulErrorKind,
-    bytes: Vec<u8>,
-}
-
-#[derive(Clone, PartialEq, Eq, Debug)]
-enum FromBytesWithNulErrorKind {
-    InteriorNul(usize),
-    NotNulTerminated,
-}
-
-impl FromBytesWithNulError {
-    fn interior_nul(pos: usize) -> FromBytesWithNulError {
-        FromBytesWithNulError { kind: FromBytesWithNulErrorKind::InteriorNul(pos) }
-    }
-    fn not_nul_terminated() -> FromBytesWithNulError {
-        FromBytesWithNulError { kind: FromBytesWithNulErrorKind::NotNulTerminated }
-    }
-}
-
-#[unstable(feature = "cstring_from_vec_with_nul", issue = "73179")]
-impl FromVecWithNulError {
-    /// Returns a slice of [`u8`]s bytes that were attempted to convert to a [`CString`].
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// #![feature(cstring_from_vec_with_nul)]
-    /// use std::ffi::CString;
-    ///
-    /// // Some invalid bytes in a vector
-    /// let bytes = b"f\0oo".to_vec();
-    ///
-    /// let value = CString::from_vec_with_nul(bytes.clone());
-    ///
-    /// assert_eq!(&bytes[..], value.unwrap_err().as_bytes());
-    /// ```
-    ///
-    /// [`CString`]: struct.CString.html
-    pub fn as_bytes(&self) -> &[u8] {
-        &self.bytes[..]
-    }
-
-    /// Returns the bytes that were attempted to convert to a [`CString`].
-    ///
-    /// This method is carefully constructed to avoid allocation. It will
-    /// consume the error, moving out the bytes, so that a copy of the bytes
-    /// does not need to be made.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// #![feature(cstring_from_vec_with_nul)]
-    /// use std::ffi::CString;
-    ///
-    /// // Some invalid bytes in a vector
-    /// let bytes = b"f\0oo".to_vec();
-    ///
-    /// let value = CString::from_vec_with_nul(bytes.clone());
-    ///
-    /// assert_eq!(bytes, value.unwrap_err().into_bytes());
-    /// ```
-    ///
-    /// [`CString`]: struct.CString.html
-    pub fn into_bytes(self) -> Vec<u8> {
-        self.bytes
-    }
-}
-
-/// An error indicating invalid UTF-8 when converting a [`CString`] into a [`String`].
-///
-/// `CString` is just a wrapper over a buffer of bytes with a nul
-/// terminator; [`into_string`][`CString::into_string`] performs UTF-8
-/// validation on those bytes and may return this error.
-///
-/// This `struct` is created by the
-/// [`into_string`][`CString::into_string`] method on [`CString`]. See
-/// its documentation for more.
-///
-/// [`String`]: ../string/struct.String.html
-/// [`CString`]: struct.CString.html
-/// [`CString::into_string`]: struct.CString.html#method.into_string
-#[derive(Clone, PartialEq, Eq, Debug)]
-#[stable(feature = "cstring_into", since = "1.7.0")]
-pub struct IntoStringError {
-    inner: CString,
-    error: Utf8Error,
-}
-
-impl CString {
-    /// Creates a new C-compatible string from a container of bytes.
-    ///
-    /// This function will consume the provided data and use the
-    /// underlying bytes to construct a new string, ensuring that
-    /// there is a trailing 0 byte. This trailing 0 byte will be
-    /// appended by this function; the provided data should *not*
-    /// contain any 0 bytes in it.
-    ///
-    /// # Examples
-    ///
-    /// ```ignore (extern-declaration)
-    /// use std::ffi::CString;
-    /// use std::os::raw::c_char;
-    ///
-    /// extern { fn puts(s: *const c_char); }
-    ///
-    /// let to_print = CString::new("Hello!").expect("CString::new failed");
-    /// unsafe {
-    ///     puts(to_print.as_ptr());
-    /// }
-    /// ```
-    ///
-    /// # Errors
-    ///
-    /// This function will return an error if the supplied bytes contain an
-    /// internal 0 byte. The [`NulError`] returned will contain the bytes as well as
-    /// the position of the nul byte.
-    ///
-    /// [`NulError`]: struct.NulError.html
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn new<T: Into<Vec<u8>>>(t: T) -> Result<CString, NulError> {
-        trait SpecIntoVec {
-            fn into_vec(self) -> Vec<u8>;
-        }
-        impl<T: Into<Vec<u8>>> SpecIntoVec for T {
-            default fn into_vec(self) -> Vec<u8> {
-                self.into()
-            }
-        }
-        // Specialization for avoiding reallocation.
-        impl SpecIntoVec for &'_ [u8] {
-            fn into_vec(self) -> Vec<u8> {
-                let mut v = Vec::with_capacity(self.len() + 1);
-                v.extend(self);
-                v
-            }
-        }
-        impl SpecIntoVec for &'_ str {
-            fn into_vec(self) -> Vec<u8> {
-                let mut v = Vec::with_capacity(self.len() + 1);
-                v.extend(self.as_bytes());
-                v
-            }
-        }
-
-        Self::_new(SpecIntoVec::into_vec(t))
-    }
-
-    fn _new(bytes: Vec<u8>) -> Result<CString, NulError> {
-        match memchr::memchr(0, &bytes) {
-            Some(i) => Err(NulError(i, bytes)),
-            None => Ok(unsafe { CString::from_vec_unchecked(bytes) }),
-        }
-    }
-
-    /// Creates a C-compatible string by consuming a byte vector,
-    /// without checking for interior 0 bytes.
-    ///
-    /// This method is equivalent to [`new`] except that no runtime assertion
-    /// is made that `v` contains no 0 bytes, and it requires an actual
-    /// byte vector, not anything that can be converted to one with Into.
-    ///
-    /// [`new`]: #method.new
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ffi::CString;
-    ///
-    /// let raw = b"foo".to_vec();
-    /// unsafe {
-    ///     let c_string = CString::from_vec_unchecked(raw);
-    /// }
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub unsafe fn from_vec_unchecked(mut v: Vec<u8>) -> CString {
-        v.reserve_exact(1);
-        v.push(0);
-        CString { inner: v.into_boxed_slice() }
-    }
-
-    /// Retakes ownership of a `CString` that was transferred to C via [`into_raw`].
-    ///
-    /// Additionally, the length of the string will be recalculated from the pointer.
-    ///
-    /// # Safety
-    ///
-    /// This should only ever be called with a pointer that was earlier
-    /// obtained by calling [`into_raw`] on a `CString`. Other usage (e.g., trying to take
-    /// ownership of a string that was allocated by foreign code) is likely to lead
-    /// to undefined behavior or allocator corruption.
-    ///
-    /// It should be noted that the length isn't just "recomputed," but that
-    /// the recomputed length must match the original length from the
-    /// [`into_raw`] call. This means the [`into_raw`]/`from_raw` methods
-    /// should not be used when passing the string to C functions that can
-    /// modify the string's length.
-    ///
-    /// > **Note:** If you need to borrow a string that was allocated by
-    /// > foreign code, use [`CStr`]. If you need to take ownership of
-    /// > a string that was allocated by foreign code, you will need to
-    /// > make your own provisions for freeing it appropriately, likely
-    /// > with the foreign code's API to do that.
-    ///
-    /// [`into_raw`]: #method.into_raw
-    /// [`CStr`]: struct.CStr.html
-    ///
-    /// # Examples
-    ///
-    /// Creates a `CString`, pass ownership to an `extern` function (via raw pointer), then retake
-    /// ownership with `from_raw`:
-    ///
-    /// ```ignore (extern-declaration)
-    /// use std::ffi::CString;
-    /// use std::os::raw::c_char;
-    ///
-    /// extern {
-    ///     fn some_extern_function(s: *mut c_char);
-    /// }
-    ///
-    /// let c_string = CString::new("Hello!").expect("CString::new failed");
-    /// let raw = c_string.into_raw();
-    /// unsafe {
-    ///     some_extern_function(raw);
-    ///     let c_string = CString::from_raw(raw);
-    /// }
-    /// ```
-    #[stable(feature = "cstr_memory", since = "1.4.0")]
-    pub unsafe fn from_raw(ptr: *mut c_char) -> CString {
-        let len = sys::strlen(ptr) + 1; // Including the NUL byte
-        let slice = slice::from_raw_parts_mut(ptr, len as usize);
-        CString { inner: Box::from_raw(slice as *mut [c_char] as *mut [u8]) }
-    }
-
-    /// Consumes the `CString` and transfers ownership of the string to a C caller.
-    ///
-    /// The pointer which this function returns must be returned to Rust and reconstituted using
-    /// [`from_raw`] to be properly deallocated. Specifically, one
-    /// should *not* use the standard C `free()` function to deallocate
-    /// this string.
-    ///
-    /// Failure to call [`from_raw`] will lead to a memory leak.
-    ///
-    /// The C side must **not** modify the length of the string (by writing a
-    /// `NULL` somewhere inside the string or removing the final one) before
-    /// it makes it back into Rust using [`from_raw`]. See the safety section
-    /// in [`from_raw`].
-    ///
-    /// [`from_raw`]: #method.from_raw
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ffi::CString;
-    ///
-    /// let c_string = CString::new("foo").expect("CString::new failed");
-    ///
-    /// let ptr = c_string.into_raw();
-    ///
-    /// unsafe {
-    ///     assert_eq!(b'f', *ptr as u8);
-    ///     assert_eq!(b'o', *ptr.offset(1) as u8);
-    ///     assert_eq!(b'o', *ptr.offset(2) as u8);
-    ///     assert_eq!(b'\0', *ptr.offset(3) as u8);
-    ///
-    ///     // retake pointer to free memory
-    ///     let _ = CString::from_raw(ptr);
-    /// }
-    /// ```
-    #[inline]
-    #[stable(feature = "cstr_memory", since = "1.4.0")]
-    pub fn into_raw(self) -> *mut c_char {
-        Box::into_raw(self.into_inner()) as *mut c_char
-    }
-
-    /// Converts the `CString` into a [`String`] if it contains valid UTF-8 data.
-    ///
-    /// On failure, ownership of the original `CString` is returned.
-    ///
-    /// [`String`]: ../string/struct.String.html
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ffi::CString;
-    ///
-    /// let valid_utf8 = vec![b'f', b'o', b'o'];
-    /// let cstring = CString::new(valid_utf8).expect("CString::new failed");
-    /// assert_eq!(cstring.into_string().expect("into_string() call failed"), "foo");
-    ///
-    /// let invalid_utf8 = vec![b'f', 0xff, b'o', b'o'];
-    /// let cstring = CString::new(invalid_utf8).expect("CString::new failed");
-    /// let err = cstring.into_string().err().expect("into_string().err() failed");
-    /// assert_eq!(err.utf8_error().valid_up_to(), 1);
-    /// ```
-
-    #[stable(feature = "cstring_into", since = "1.7.0")]
-    pub fn into_string(self) -> Result<String, IntoStringError> {
-        String::from_utf8(self.into_bytes()).map_err(|e| IntoStringError {
-            error: e.utf8_error(),
-            inner: unsafe { CString::from_vec_unchecked(e.into_bytes()) },
-        })
-    }
-
-    /// Consumes the `CString` and returns the underlying byte buffer.
-    ///
-    /// The returned buffer does **not** contain the trailing nul
-    /// terminator, and it is guaranteed to not have any interior nul
-    /// bytes.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ffi::CString;
-    ///
-    /// let c_string = CString::new("foo").expect("CString::new failed");
-    /// let bytes = c_string.into_bytes();
-    /// assert_eq!(bytes, vec![b'f', b'o', b'o']);
-    /// ```
-    #[stable(feature = "cstring_into", since = "1.7.0")]
-    pub fn into_bytes(self) -> Vec<u8> {
-        let mut vec = self.into_inner().into_vec();
-        let _nul = vec.pop();
-        debug_assert_eq!(_nul, Some(0u8));
-        vec
-    }
-
-    /// Equivalent to the [`into_bytes`] function except that the returned vector
-    /// includes the trailing nul terminator.
-    ///
-    /// [`into_bytes`]: #method.into_bytes
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ffi::CString;
-    ///
-    /// let c_string = CString::new("foo").expect("CString::new failed");
-    /// let bytes = c_string.into_bytes_with_nul();
-    /// assert_eq!(bytes, vec![b'f', b'o', b'o', b'\0']);
-    /// ```
-    #[stable(feature = "cstring_into", since = "1.7.0")]
-    pub fn into_bytes_with_nul(self) -> Vec<u8> {
-        self.into_inner().into_vec()
-    }
-
-    /// Returns the contents of this `CString` as a slice of bytes.
-    ///
-    /// The returned slice does **not** contain the trailing nul
-    /// terminator, and it is guaranteed to not have any interior nul
-    /// bytes. If you need the nul terminator, use
-    /// [`as_bytes_with_nul`] instead.
-    ///
-    /// [`as_bytes_with_nul`]: #method.as_bytes_with_nul
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ffi::CString;
-    ///
-    /// let c_string = CString::new("foo").expect("CString::new failed");
-    /// let bytes = c_string.as_bytes();
-    /// assert_eq!(bytes, &[b'f', b'o', b'o']);
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn as_bytes(&self) -> &[u8] {
-        &self.inner[..self.inner.len() - 1]
-    }
-
-    /// Equivalent to the [`as_bytes`] function except that the returned slice
-    /// includes the trailing nul terminator.
-    ///
-    /// [`as_bytes`]: #method.as_bytes
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ffi::CString;
-    ///
-    /// let c_string = CString::new("foo").expect("CString::new failed");
-    /// let bytes = c_string.as_bytes_with_nul();
-    /// assert_eq!(bytes, &[b'f', b'o', b'o', b'\0']);
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn as_bytes_with_nul(&self) -> &[u8] {
-        &self.inner
-    }
-
-    /// Extracts a [`CStr`] slice containing the entire string.
-    ///
-    /// [`CStr`]: struct.CStr.html
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ffi::{CString, CStr};
-    ///
-    /// let c_string = CString::new(b"foo".to_vec()).expect("CString::new failed");
-    /// let cstr = c_string.as_c_str();
-    /// assert_eq!(cstr,
-    ///            CStr::from_bytes_with_nul(b"foo\0").expect("CStr::from_bytes_with_nul failed"));
-    /// ```
-    #[inline]
-    #[stable(feature = "as_c_str", since = "1.20.0")]
-    pub fn as_c_str(&self) -> &CStr {
-        &*self
-    }
-
-    /// Converts this `CString` into a boxed [`CStr`].
-    ///
-    /// [`CStr`]: struct.CStr.html
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ffi::{CString, CStr};
-    ///
-    /// let c_string = CString::new(b"foo".to_vec()).expect("CString::new failed");
-    /// let boxed = c_string.into_boxed_c_str();
-    /// assert_eq!(&*boxed,
-    ///            CStr::from_bytes_with_nul(b"foo\0").expect("CStr::from_bytes_with_nul failed"));
-    /// ```
-    #[stable(feature = "into_boxed_c_str", since = "1.20.0")]
-    pub fn into_boxed_c_str(self) -> Box<CStr> {
-        unsafe { Box::from_raw(Box::into_raw(self.into_inner()) as *mut CStr) }
-    }
-
-    /// Bypass "move out of struct which implements [`Drop`] trait" restriction.
-    ///
-    /// [`Drop`]: ../ops/trait.Drop.html
-    fn into_inner(self) -> Box<[u8]> {
-        // Rationale: `mem::forget(self)` invalidates the previous call to `ptr::read(&self.inner)`
-        // so we use `ManuallyDrop` to ensure `self` is not dropped.
-        // Then we can return the box directly without invalidating it.
-        // See https://github.com/rust-lang/rust/issues/62553.
-        let this = mem::ManuallyDrop::new(self);
-        unsafe { ptr::read(&this.inner) }
-    }
-
-    /// Converts a `Vec` of `u8` to a `CString` without checking the invariants
-    /// on the given `Vec`.
-    ///
-    /// # Safety
-    ///
-    /// The given `Vec` **must** have one nul byte as its last element.
-    /// This means it cannot be empty nor have any other nul byte anywhere else.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// #![feature(cstring_from_vec_with_nul)]
-    /// use std::ffi::CString;
-    /// assert_eq!(
-    ///     unsafe { CString::from_vec_with_nul_unchecked(b"abc\0".to_vec()) },
-    ///     unsafe { CString::from_vec_unchecked(b"abc".to_vec()) }
-    /// );
-    /// ```
-    #[unstable(feature = "cstring_from_vec_with_nul", issue = "73179")]
-    pub unsafe fn from_vec_with_nul_unchecked(v: Vec<u8>) -> Self {
-        Self { inner: v.into_boxed_slice() }
-    }
-
-    /// Attempts to converts a `Vec` of `u8` to a `CString`.
-    ///
-    /// Runtime checks are present to ensure there is only one nul byte in the
-    /// `Vec`, its last element.
-    ///
-    /// # Errors
-    ///
-    /// If a nul byte is present and not the last element or no nul bytes
-    /// is present, an error will be returned.
-    ///
-    /// # Examples
-    ///
-    /// A successful conversion will produce the same result as [`new`] when
-    /// called without the ending nul byte.
-    ///
-    /// ```
-    /// #![feature(cstring_from_vec_with_nul)]
-    /// use std::ffi::CString;
-    /// assert_eq!(
-    ///     CString::from_vec_with_nul(b"abc\0".to_vec())
-    ///         .expect("CString::from_vec_with_nul failed"),
-    ///     CString::new(b"abc".to_vec()).expect("CString::new failed")
-    /// );
-    /// ```
-    ///
-    /// A incorrectly formatted vector will produce an error.
-    ///
-    /// ```
-    /// #![feature(cstring_from_vec_with_nul)]
-    /// use std::ffi::{CString, FromVecWithNulError};
-    /// // Interior nul byte
-    /// let _: FromVecWithNulError = CString::from_vec_with_nul(b"a\0bc".to_vec()).unwrap_err();
-    /// // No nul byte
-    /// let _: FromVecWithNulError = CString::from_vec_with_nul(b"abc".to_vec()).unwrap_err();
-    /// ```
-    ///
-    /// [`new`]: #method.new
-    #[unstable(feature = "cstring_from_vec_with_nul", issue = "73179")]
-    pub fn from_vec_with_nul(v: Vec<u8>) -> Result<Self, FromVecWithNulError> {
-        let nul_pos = memchr::memchr(0, &v);
-        match nul_pos {
-            Some(nul_pos) if nul_pos + 1 == v.len() => {
-                // SAFETY: We know there is only one nul byte, at the end
-                // of the vec.
-                Ok(unsafe { Self::from_vec_with_nul_unchecked(v) })
-            }
-            Some(nul_pos) => Err(FromVecWithNulError {
-                error_kind: FromBytesWithNulErrorKind::InteriorNul(nul_pos),
-                bytes: v,
-            }),
-            None => Err(FromVecWithNulError {
-                error_kind: FromBytesWithNulErrorKind::NotNulTerminated,
-                bytes: v,
-            }),
-        }
-    }
-}
-
-// Turns this `CString` into an empty string to prevent
-// memory-unsafe code from working by accident. Inline
-// to prevent LLVM from optimizing it away in debug builds.
-#[stable(feature = "cstring_drop", since = "1.13.0")]
-impl Drop for CString {
-    #[inline]
-    fn drop(&mut self) {
-        unsafe {
-            *self.inner.get_unchecked_mut(0) = 0;
-        }
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl ops::Deref for CString {
-    type Target = CStr;
-
-    #[inline]
-    fn deref(&self) -> &CStr {
-        unsafe { CStr::from_bytes_with_nul_unchecked(self.as_bytes_with_nul()) }
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl fmt::Debug for CString {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Debug::fmt(&**self, f)
-    }
-}
-
-#[stable(feature = "cstring_into", since = "1.7.0")]
-impl From<CString> for Vec<u8> {
-    /// Converts a [`CString`] into a [`Vec`]`<u8>`.
-    ///
-    /// The conversion consumes the [`CString`], and removes the terminating NUL byte.
-    ///
-    /// [`Vec`]: ../vec/struct.Vec.html
-    /// [`CString`]: ../ffi/struct.CString.html
-    #[inline]
-    fn from(s: CString) -> Vec<u8> {
-        s.into_bytes()
-    }
-}
-
-#[stable(feature = "cstr_debug", since = "1.3.0")]
-impl fmt::Debug for CStr {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "\"")?;
-        for byte in self.to_bytes().iter().flat_map(|&b| ascii::escape_default(b)) {
-            f.write_char(byte as char)?;
-        }
-        write!(f, "\"")
-    }
-}
-
-#[stable(feature = "cstr_default", since = "1.10.0")]
-impl Default for &CStr {
-    fn default() -> Self {
-        const SLICE: &[c_char] = &[0];
-        unsafe { CStr::from_ptr(SLICE.as_ptr()) }
-    }
-}
-
-#[stable(feature = "cstr_default", since = "1.10.0")]
-impl Default for CString {
-    /// Creates an empty `CString`.
-    fn default() -> CString {
-        let a: &CStr = Default::default();
-        a.to_owned()
-    }
-}
-
-#[stable(feature = "cstr_borrow", since = "1.3.0")]
-impl Borrow<CStr> for CString {
-    #[inline]
-    fn borrow(&self) -> &CStr {
-        self
-    }
-}
-
-#[stable(feature = "cstring_from_cow_cstr", since = "1.28.0")]
-impl<'a> From<Cow<'a, CStr>> for CString {
-    #[inline]
-    fn from(s: Cow<'a, CStr>) -> Self {
-        s.into_owned()
-    }
-}
-
-#[stable(feature = "box_from_c_str", since = "1.17.0")]
-impl From<&CStr> for Box<CStr> {
-    fn from(s: &CStr) -> Box<CStr> {
-        let boxed: Box<[u8]> = Box::from(s.to_bytes_with_nul());
-        unsafe { Box::from_raw(Box::into_raw(boxed) as *mut CStr) }
-    }
-}
-
-#[stable(feature = "box_from_cow", since = "1.45.0")]
-impl From<Cow<'_, CStr>> for Box<CStr> {
-    #[inline]
-    fn from(cow: Cow<'_, CStr>) -> Box<CStr> {
-        match cow {
-            Cow::Borrowed(s) => Box::from(s),
-            Cow::Owned(s) => Box::from(s),
-        }
-    }
-}
-
-#[stable(feature = "c_string_from_box", since = "1.18.0")]
-impl From<Box<CStr>> for CString {
-    /// Converts a [`Box`]`<CStr>` into a [`CString`] without copying or allocating.
-    ///
-    /// [`Box`]: ../boxed/struct.Box.html
-    /// [`CString`]: ../ffi/struct.CString.html
-    #[inline]
-    fn from(s: Box<CStr>) -> CString {
-        s.into_c_string()
-    }
-}
-
-#[stable(feature = "cstring_from_vec_of_nonzerou8", since = "1.43.0")]
-impl From<Vec<NonZeroU8>> for CString {
-    /// Converts a [`Vec`]`<`[`NonZeroU8`]`>` into a [`CString`] without
-    /// copying nor checking for inner null bytes.
-    ///
-    /// [`CString`]: ../ffi/struct.CString.html
-    /// [`NonZeroU8`]: ../num/struct.NonZeroU8.html
-    /// [`Vec`]: ../vec/struct.Vec.html
-    #[inline]
-    fn from(v: Vec<NonZeroU8>) -> CString {
-        unsafe {
-            // Transmute `Vec<NonZeroU8>` to `Vec<u8>`.
-            let v: Vec<u8> = {
-                // Safety:
-                //   - transmuting between `NonZeroU8` and `u8` is sound;
-                //   - `alloc::Layout<NonZeroU8> == alloc::Layout<u8>`.
-                let (ptr, len, cap): (*mut NonZeroU8, _, _) = Vec::into_raw_parts(v);
-                Vec::from_raw_parts(ptr.cast::<u8>(), len, cap)
-            };
-            // Safety: `v` cannot contain null bytes, given the type-level
-            // invariant of `NonZeroU8`.
-            CString::from_vec_unchecked(v)
-        }
-    }
-}
-
-#[stable(feature = "more_box_slice_clone", since = "1.29.0")]
-impl Clone for Box<CStr> {
-    #[inline]
-    fn clone(&self) -> Self {
-        (**self).into()
-    }
-}
-
-#[stable(feature = "box_from_c_string", since = "1.20.0")]
-impl From<CString> for Box<CStr> {
-    /// Converts a [`CString`] into a [`Box`]`<CStr>` without copying or allocating.
-    ///
-    /// [`CString`]: ../ffi/struct.CString.html
-    /// [`Box`]: ../boxed/struct.Box.html
-    #[inline]
-    fn from(s: CString) -> Box<CStr> {
-        s.into_boxed_c_str()
-    }
-}
-
-#[stable(feature = "cow_from_cstr", since = "1.28.0")]
-impl<'a> From<CString> for Cow<'a, CStr> {
-    #[inline]
-    fn from(s: CString) -> Cow<'a, CStr> {
-        Cow::Owned(s)
-    }
-}
-
-#[stable(feature = "cow_from_cstr", since = "1.28.0")]
-impl<'a> From<&'a CStr> for Cow<'a, CStr> {
-    #[inline]
-    fn from(s: &'a CStr) -> Cow<'a, CStr> {
-        Cow::Borrowed(s)
-    }
-}
-
-#[stable(feature = "cow_from_cstr", since = "1.28.0")]
-impl<'a> From<&'a CString> for Cow<'a, CStr> {
-    #[inline]
-    fn from(s: &'a CString) -> Cow<'a, CStr> {
-        Cow::Borrowed(s.as_c_str())
-    }
-}
-
-#[stable(feature = "shared_from_slice2", since = "1.24.0")]
-impl From<CString> for Arc<CStr> {
-    /// Converts a [`CString`] into a [`Arc`]`<CStr>` without copying or allocating.
-    ///
-    /// [`CString`]: ../ffi/struct.CString.html
-    /// [`Arc`]: ../sync/struct.Arc.html
-    #[inline]
-    fn from(s: CString) -> Arc<CStr> {
-        let arc: Arc<[u8]> = Arc::from(s.into_inner());
-        unsafe { Arc::from_raw(Arc::into_raw(arc) as *const CStr) }
-    }
-}
-
-#[stable(feature = "shared_from_slice2", since = "1.24.0")]
-impl From<&CStr> for Arc<CStr> {
-    #[inline]
-    fn from(s: &CStr) -> Arc<CStr> {
-        let arc: Arc<[u8]> = Arc::from(s.to_bytes_with_nul());
-        unsafe { Arc::from_raw(Arc::into_raw(arc) as *const CStr) }
-    }
-}
-
-#[stable(feature = "shared_from_slice2", since = "1.24.0")]
-impl From<CString> for Rc<CStr> {
-    /// Converts a [`CString`] into a [`Rc`]`<CStr>` without copying or allocating.
-    ///
-    /// [`CString`]: ../ffi/struct.CString.html
-    /// [`Rc`]: ../rc/struct.Rc.html
-    #[inline]
-    fn from(s: CString) -> Rc<CStr> {
-        let rc: Rc<[u8]> = Rc::from(s.into_inner());
-        unsafe { Rc::from_raw(Rc::into_raw(rc) as *const CStr) }
-    }
-}
-
-#[stable(feature = "shared_from_slice2", since = "1.24.0")]
-impl From<&CStr> for Rc<CStr> {
-    #[inline]
-    fn from(s: &CStr) -> Rc<CStr> {
-        let rc: Rc<[u8]> = Rc::from(s.to_bytes_with_nul());
-        unsafe { Rc::from_raw(Rc::into_raw(rc) as *const CStr) }
-    }
-}
-
-#[stable(feature = "default_box_extra", since = "1.17.0")]
-impl Default for Box<CStr> {
-    fn default() -> Box<CStr> {
-        let boxed: Box<[u8]> = Box::from([0]);
-        unsafe { Box::from_raw(Box::into_raw(boxed) as *mut CStr) }
-    }
-}
-
-impl NulError {
-    /// Returns the position of the nul byte in the slice that caused
-    /// [`CString::new`] to fail.
-    ///
-    /// [`CString::new`]: struct.CString.html#method.new
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ffi::CString;
-    ///
-    /// let nul_error = CString::new("foo\0bar").unwrap_err();
-    /// assert_eq!(nul_error.nul_position(), 3);
-    ///
-    /// let nul_error = CString::new("foo bar\0").unwrap_err();
-    /// assert_eq!(nul_error.nul_position(), 7);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn nul_position(&self) -> usize {
-        self.0
-    }
-
-    /// Consumes this error, returning the underlying vector of bytes which
-    /// generated the error in the first place.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ffi::CString;
-    ///
-    /// let nul_error = CString::new("foo\0bar").unwrap_err();
-    /// assert_eq!(nul_error.into_vec(), b"foo\0bar");
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn into_vec(self) -> Vec<u8> {
-        self.1
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl Error for NulError {
-    #[allow(deprecated)]
-    fn description(&self) -> &str {
-        "nul byte found in data"
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl fmt::Display for NulError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "nul byte found in provided data at position: {}", self.0)
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl From<NulError> for io::Error {
-    /// Converts a [`NulError`] into a [`io::Error`].
-    ///
-    /// [`NulError`]: ../ffi/struct.NulError.html
-    /// [`io::Error`]: ../io/struct.Error.html
-    fn from(_: NulError) -> io::Error {
-        io::Error::new(io::ErrorKind::InvalidInput, "data provided contains a nul byte")
-    }
-}
-
-#[stable(feature = "frombyteswithnulerror_impls", since = "1.17.0")]
-impl Error for FromBytesWithNulError {
-    #[allow(deprecated)]
-    fn description(&self) -> &str {
-        match self.kind {
-            FromBytesWithNulErrorKind::InteriorNul(..) => {
-                "data provided contains an interior nul byte"
-            }
-            FromBytesWithNulErrorKind::NotNulTerminated => "data provided is not nul terminated",
-        }
-    }
-}
-
-#[stable(feature = "frombyteswithnulerror_impls", since = "1.17.0")]
-impl fmt::Display for FromBytesWithNulError {
-    #[allow(deprecated, deprecated_in_future)]
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str(self.description())?;
-        if let FromBytesWithNulErrorKind::InteriorNul(pos) = self.kind {
-            write!(f, " at byte pos {}", pos)?;
-        }
-        Ok(())
-    }
-}
-
-#[unstable(feature = "cstring_from_vec_with_nul", issue = "73179")]
-impl Error for FromVecWithNulError {}
-
-#[unstable(feature = "cstring_from_vec_with_nul", issue = "73179")]
-impl fmt::Display for FromVecWithNulError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self.error_kind {
-            FromBytesWithNulErrorKind::InteriorNul(pos) => {
-                write!(f, "data provided contains an interior nul byte at pos {}", pos)
-            }
-            FromBytesWithNulErrorKind::NotNulTerminated => {
-                write!(f, "data provided is not nul terminated")
-            }
-        }
-    }
-}
-
-impl IntoStringError {
-    /// Consumes this error, returning original [`CString`] which generated the
-    /// error.
-    ///
-    /// [`CString`]: struct.CString.html
-    #[stable(feature = "cstring_into", since = "1.7.0")]
-    pub fn into_cstring(self) -> CString {
-        self.inner
-    }
-
-    /// Access the underlying UTF-8 error that was the cause of this error.
-    #[stable(feature = "cstring_into", since = "1.7.0")]
-    pub fn utf8_error(&self) -> Utf8Error {
-        self.error
-    }
-}
-
-#[stable(feature = "cstring_into", since = "1.7.0")]
-impl Error for IntoStringError {
-    #[allow(deprecated)]
-    fn description(&self) -> &str {
-        "C string contained non-utf8 bytes"
-    }
-
-    fn source(&self) -> Option<&(dyn Error + 'static)> {
-        Some(&self.error)
-    }
-}
-
-#[stable(feature = "cstring_into", since = "1.7.0")]
-impl fmt::Display for IntoStringError {
-    #[allow(deprecated, deprecated_in_future)]
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.description().fmt(f)
-    }
-}
-
-impl CStr {
-    /// Wraps a raw C string with a safe C string wrapper.
-    ///
-    /// This function will wrap the provided `ptr` with a `CStr` wrapper, which
-    /// allows inspection and interoperation of non-owned C strings. The total
-    /// size of the raw C string must be smaller than `isize::MAX` **bytes**
-    /// in memory due to calling the `slice::from_raw_parts` function.
-    /// This method is unsafe for a number of reasons:
-    ///
-    /// * There is no guarantee to the validity of `ptr`.
-    /// * The returned lifetime is not guaranteed to be the actual lifetime of
-    ///   `ptr`.
-    /// * There is no guarantee that the memory pointed to by `ptr` contains a
-    ///   valid nul terminator byte at the end of the string.
-    /// * It is not guaranteed that the memory pointed by `ptr` won't change
-    ///   before the `CStr` has been destroyed.
-    ///
-    /// > **Note**: This operation is intended to be a 0-cost cast but it is
-    /// > currently implemented with an up-front calculation of the length of
-    /// > the string. This is not guaranteed to always be the case.
-    ///
-    /// # Examples
-    ///
-    /// ```ignore (extern-declaration)
-    /// # fn main() {
-    /// use std::ffi::CStr;
-    /// use std::os::raw::c_char;
-    ///
-    /// extern {
-    ///     fn my_string() -> *const c_char;
-    /// }
-    ///
-    /// unsafe {
-    ///     let slice = CStr::from_ptr(my_string());
-    ///     println!("string returned: {}", slice.to_str().unwrap());
-    /// }
-    /// # }
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub unsafe fn from_ptr<'a>(ptr: *const c_char) -> &'a CStr {
-        let len = sys::strlen(ptr);
-        let ptr = ptr as *const u8;
-        CStr::from_bytes_with_nul_unchecked(slice::from_raw_parts(ptr, len as usize + 1))
-    }
-
-    /// Creates a C string wrapper from a byte slice.
-    ///
-    /// This function will cast the provided `bytes` to a `CStr`
-    /// wrapper after ensuring that the byte slice is nul-terminated
-    /// and does not contain any interior nul bytes.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ffi::CStr;
-    ///
-    /// let cstr = CStr::from_bytes_with_nul(b"hello\0");
-    /// assert!(cstr.is_ok());
-    /// ```
-    ///
-    /// Creating a `CStr` without a trailing nul terminator is an error:
-    ///
-    /// ```
-    /// use std::ffi::CStr;
-    ///
-    /// let cstr = CStr::from_bytes_with_nul(b"hello");
-    /// assert!(cstr.is_err());
-    /// ```
-    ///
-    /// Creating a `CStr` with an interior nul byte is an error:
-    ///
-    /// ```
-    /// use std::ffi::CStr;
-    ///
-    /// let cstr = CStr::from_bytes_with_nul(b"he\0llo\0");
-    /// assert!(cstr.is_err());
-    /// ```
-    #[stable(feature = "cstr_from_bytes", since = "1.10.0")]
-    pub fn from_bytes_with_nul(bytes: &[u8]) -> Result<&CStr, FromBytesWithNulError> {
-        let nul_pos = memchr::memchr(0, bytes);
-        if let Some(nul_pos) = nul_pos {
-            if nul_pos + 1 != bytes.len() {
-                return Err(FromBytesWithNulError::interior_nul(nul_pos));
-            }
-            Ok(unsafe { CStr::from_bytes_with_nul_unchecked(bytes) })
-        } else {
-            Err(FromBytesWithNulError::not_nul_terminated())
-        }
-    }
-
-    /// Unsafely creates a C string wrapper from a byte slice.
-    ///
-    /// This function will cast the provided `bytes` to a `CStr` wrapper without
-    /// performing any sanity checks. The provided slice **must** be nul-terminated
-    /// and not contain any interior nul bytes.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ffi::{CStr, CString};
-    ///
-    /// unsafe {
-    ///     let cstring = CString::new("hello").expect("CString::new failed");
-    ///     let cstr = CStr::from_bytes_with_nul_unchecked(cstring.to_bytes_with_nul());
-    ///     assert_eq!(cstr, &*cstring);
-    /// }
-    /// ```
-    #[inline]
-    #[stable(feature = "cstr_from_bytes", since = "1.10.0")]
-    #[rustc_const_unstable(feature = "const_cstr_unchecked", issue = "none")]
-    pub const unsafe fn from_bytes_with_nul_unchecked(bytes: &[u8]) -> &CStr {
-        &*(bytes as *const [u8] as *const CStr)
-    }
-
-    /// Returns the inner pointer to this C string.
-    ///
-    /// The returned pointer will be valid for as long as `self` is, and points
-    /// to a contiguous region of memory terminated with a 0 byte to represent
-    /// the end of the string.
-    ///
-    /// **WARNING**
-    ///
-    /// The returned pointer is read-only; writing to it (including passing it
-    /// to C code that writes to it) causes undefined behavior.
-    ///
-    /// It is your responsibility to make sure that the underlying memory is not
-    /// freed too early. For example, the following code will cause undefined
-    /// behavior when `ptr` is used inside the `unsafe` block:
-    ///
-    /// ```no_run
-    /// # #![allow(unused_must_use)]
-    /// use std::ffi::CString;
-    ///
-    /// let ptr = CString::new("Hello").expect("CString::new failed").as_ptr();
-    /// unsafe {
-    ///     // `ptr` is dangling
-    ///     *ptr;
-    /// }
-    /// ```
-    ///
-    /// This happens because the pointer returned by `as_ptr` does not carry any
-    /// lifetime information and the [`CString`] is deallocated immediately after
-    /// the `CString::new("Hello").expect("CString::new failed").as_ptr()` expression is evaluated.
-    /// To fix the problem, bind the `CString` to a local variable:
-    ///
-    /// ```no_run
-    /// # #![allow(unused_must_use)]
-    /// use std::ffi::CString;
-    ///
-    /// let hello = CString::new("Hello").expect("CString::new failed");
-    /// let ptr = hello.as_ptr();
-    /// unsafe {
-    ///     // `ptr` is valid because `hello` is in scope
-    ///     *ptr;
-    /// }
-    /// ```
-    ///
-    /// This way, the lifetime of the `CString` in `hello` encompasses
-    /// the lifetime of `ptr` and the `unsafe` block.
-    ///
-    /// [`CString`]: struct.CString.html
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[rustc_const_stable(feature = "const_str_as_ptr", since = "1.32.0")]
-    pub const fn as_ptr(&self) -> *const c_char {
-        self.inner.as_ptr()
-    }
-
-    /// Converts this C string to a byte slice.
-    ///
-    /// The returned slice will **not** contain the trailing nul terminator that this C
-    /// string has.
-    ///
-    /// > **Note**: This method is currently implemented as a constant-time
-    /// > cast, but it is planned to alter its definition in the future to
-    /// > perform the length calculation whenever this method is called.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ffi::CStr;
-    ///
-    /// let cstr = CStr::from_bytes_with_nul(b"foo\0").expect("CStr::from_bytes_with_nul failed");
-    /// assert_eq!(cstr.to_bytes(), b"foo");
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn to_bytes(&self) -> &[u8] {
-        let bytes = self.to_bytes_with_nul();
-        &bytes[..bytes.len() - 1]
-    }
-
-    /// Converts this C string to a byte slice containing the trailing 0 byte.
-    ///
-    /// This function is the equivalent of [`to_bytes`] except that it will retain
-    /// the trailing nul terminator instead of chopping it off.
-    ///
-    /// > **Note**: This method is currently implemented as a 0-cost cast, but
-    /// > it is planned to alter its definition in the future to perform the
-    /// > length calculation whenever this method is called.
-    ///
-    /// [`to_bytes`]: #method.to_bytes
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ffi::CStr;
-    ///
-    /// let cstr = CStr::from_bytes_with_nul(b"foo\0").expect("CStr::from_bytes_with_nul failed");
-    /// assert_eq!(cstr.to_bytes_with_nul(), b"foo\0");
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn to_bytes_with_nul(&self) -> &[u8] {
-        unsafe { &*(&self.inner as *const [c_char] as *const [u8]) }
-    }
-
-    /// Yields a [`&str`] slice if the `CStr` contains valid UTF-8.
-    ///
-    /// If the contents of the `CStr` are valid UTF-8 data, this
-    /// function will return the corresponding [`&str`] slice. Otherwise,
-    /// it will return an error with details of where UTF-8 validation failed.
-    ///
-    /// [`&str`]: ../primitive.str.html
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ffi::CStr;
-    ///
-    /// let cstr = CStr::from_bytes_with_nul(b"foo\0").expect("CStr::from_bytes_with_nul failed");
-    /// assert_eq!(cstr.to_str(), Ok("foo"));
-    /// ```
-    #[stable(feature = "cstr_to_str", since = "1.4.0")]
-    pub fn to_str(&self) -> Result<&str, 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
-        // instead of doing it afterwards.
-        str::from_utf8(self.to_bytes())
-    }
-
-    /// Converts a `CStr` into a [`Cow`]`<`[`str`]`>`.
-    ///
-    /// If the contents of the `CStr` are valid UTF-8 data, this
-    /// function will return a [`Cow`]`::`[`Borrowed`]`(`[`&str`]`)`
-    /// with the corresponding [`&str`] slice. Otherwise, it will
-    /// replace any invalid UTF-8 sequences with
-    /// [`U+FFFD REPLACEMENT CHARACTER`][U+FFFD] and return a
-    /// [`Cow`]`::`[`Owned`]`(`[`String`]`)` with the result.
-    ///
-    /// [`Cow`]: ../borrow/enum.Cow.html
-    /// [`Borrowed`]: ../borrow/enum.Cow.html#variant.Borrowed
-    /// [`Owned`]: ../borrow/enum.Cow.html#variant.Owned
-    /// [`str`]: ../primitive.str.html
-    /// [`String`]: ../string/struct.String.html
-    /// [U+FFFD]: ../char/constant.REPLACEMENT_CHARACTER.html
-    ///
-    /// # Examples
-    ///
-    /// Calling `to_string_lossy` on a `CStr` containing valid UTF-8:
-    ///
-    /// ```
-    /// use std::borrow::Cow;
-    /// use std::ffi::CStr;
-    ///
-    /// let cstr = CStr::from_bytes_with_nul(b"Hello World\0")
-    ///                  .expect("CStr::from_bytes_with_nul failed");
-    /// assert_eq!(cstr.to_string_lossy(), Cow::Borrowed("Hello World"));
-    /// ```
-    ///
-    /// Calling `to_string_lossy` on a `CStr` containing invalid UTF-8:
-    ///
-    /// ```
-    /// use std::borrow::Cow;
-    /// use std::ffi::CStr;
-    ///
-    /// let cstr = CStr::from_bytes_with_nul(b"Hello \xF0\x90\x80World\0")
-    ///                  .expect("CStr::from_bytes_with_nul failed");
-    /// assert_eq!(
-    ///     cstr.to_string_lossy(),
-    ///     Cow::Owned(String::from("Hello �World")) as Cow<'_, str>
-    /// );
-    /// ```
-    #[stable(feature = "cstr_to_str", since = "1.4.0")]
-    pub fn to_string_lossy(&self) -> Cow<'_, str> {
-        String::from_utf8_lossy(self.to_bytes())
-    }
-
-    /// Converts a [`Box`]`<CStr>` into a [`CString`] without copying or allocating.
-    ///
-    /// [`Box`]: ../boxed/struct.Box.html
-    /// [`CString`]: struct.CString.html
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ffi::CString;
-    ///
-    /// let c_string = CString::new(b"foo".to_vec()).expect("CString::new failed");
-    /// let boxed = c_string.into_boxed_c_str();
-    /// assert_eq!(boxed.into_c_string(), CString::new("foo").expect("CString::new failed"));
-    /// ```
-    #[stable(feature = "into_boxed_c_str", since = "1.20.0")]
-    pub fn into_c_string(self: Box<CStr>) -> CString {
-        let raw = Box::into_raw(self) as *mut [u8];
-        CString { inner: unsafe { Box::from_raw(raw) } }
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl PartialEq for CStr {
-    fn eq(&self, other: &CStr) -> bool {
-        self.to_bytes().eq(other.to_bytes())
-    }
-}
-#[stable(feature = "rust1", since = "1.0.0")]
-impl Eq for CStr {}
-#[stable(feature = "rust1", since = "1.0.0")]
-impl PartialOrd for CStr {
-    fn partial_cmp(&self, other: &CStr) -> Option<Ordering> {
-        self.to_bytes().partial_cmp(&other.to_bytes())
-    }
-}
-#[stable(feature = "rust1", since = "1.0.0")]
-impl Ord for CStr {
-    fn cmp(&self, other: &CStr) -> Ordering {
-        self.to_bytes().cmp(&other.to_bytes())
-    }
-}
-
-#[stable(feature = "cstr_borrow", since = "1.3.0")]
-impl ToOwned for CStr {
-    type Owned = CString;
-
-    fn to_owned(&self) -> CString {
-        CString { inner: self.to_bytes_with_nul().into() }
-    }
-
-    fn clone_into(&self, target: &mut CString) {
-        let mut b = Vec::from(mem::take(&mut target.inner));
-        self.to_bytes_with_nul().clone_into(&mut b);
-        target.inner = b.into_boxed_slice();
-    }
-}
-
-#[stable(feature = "cstring_asref", since = "1.7.0")]
-impl From<&CStr> for CString {
-    fn from(s: &CStr) -> CString {
-        s.to_owned()
-    }
-}
-
-#[stable(feature = "cstring_asref", since = "1.7.0")]
-impl ops::Index<ops::RangeFull> for CString {
-    type Output = CStr;
-
-    #[inline]
-    fn index(&self, _index: ops::RangeFull) -> &CStr {
-        self
-    }
-}
-
-#[stable(feature = "cstr_range_from", since = "1.47.0")]
-impl ops::Index<ops::RangeFrom<usize>> for CStr {
-    type Output = CStr;
-
-    fn index(&self, index: ops::RangeFrom<usize>) -> &CStr {
-        let bytes = self.to_bytes_with_nul();
-        // we need to manually check the starting index to account for the null
-        // byte, since otherwise we could get an empty string that doesn't end
-        // in a null.
-        if index.start < bytes.len() {
-            unsafe { CStr::from_bytes_with_nul_unchecked(&bytes[index.start..]) }
-        } else {
-            panic!(
-                "index out of bounds: the len is {} but the index is {}",
-                bytes.len(),
-                index.start
-            );
-        }
-    }
-}
-
-#[stable(feature = "cstring_asref", since = "1.7.0")]
-impl AsRef<CStr> for CStr {
-    #[inline]
-    fn as_ref(&self) -> &CStr {
-        self
-    }
-}
-
-#[stable(feature = "cstring_asref", since = "1.7.0")]
-impl AsRef<CStr> for CString {
-    #[inline]
-    fn as_ref(&self) -> &CStr {
-        self
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::borrow::Cow::{Borrowed, Owned};
-    use crate::collections::hash_map::DefaultHasher;
-    use crate::hash::{Hash, Hasher};
-    use crate::os::raw::c_char;
-    use crate::rc::Rc;
-    use crate::sync::Arc;
-
-    #[test]
-    fn c_to_rust() {
-        let data = b"123\0";
-        let ptr = data.as_ptr() as *const c_char;
-        unsafe {
-            assert_eq!(CStr::from_ptr(ptr).to_bytes(), b"123");
-            assert_eq!(CStr::from_ptr(ptr).to_bytes_with_nul(), b"123\0");
-        }
-    }
-
-    #[test]
-    fn simple() {
-        let s = CString::new("1234").unwrap();
-        assert_eq!(s.as_bytes(), b"1234");
-        assert_eq!(s.as_bytes_with_nul(), b"1234\0");
-    }
-
-    #[test]
-    fn build_with_zero1() {
-        assert!(CString::new(&b"\0"[..]).is_err());
-    }
-    #[test]
-    fn build_with_zero2() {
-        assert!(CString::new(vec![0]).is_err());
-    }
-
-    #[test]
-    fn build_with_zero3() {
-        unsafe {
-            let s = CString::from_vec_unchecked(vec![0]);
-            assert_eq!(s.as_bytes(), b"\0");
-        }
-    }
-
-    #[test]
-    fn formatted() {
-        let s = CString::new(&b"abc\x01\x02\n\xE2\x80\xA6\xFF"[..]).unwrap();
-        assert_eq!(format!("{:?}", s), r#""abc\x01\x02\n\xe2\x80\xa6\xff""#);
-    }
-
-    #[test]
-    fn borrowed() {
-        unsafe {
-            let s = CStr::from_ptr(b"12\0".as_ptr() as *const _);
-            assert_eq!(s.to_bytes(), b"12");
-            assert_eq!(s.to_bytes_with_nul(), b"12\0");
-        }
-    }
-
-    #[test]
-    fn to_str() {
-        let data = b"123\xE2\x80\xA6\0";
-        let ptr = data.as_ptr() as *const c_char;
-        unsafe {
-            assert_eq!(CStr::from_ptr(ptr).to_str(), Ok("123…"));
-            assert_eq!(CStr::from_ptr(ptr).to_string_lossy(), Borrowed("123…"));
-        }
-        let data = b"123\xE2\0";
-        let ptr = data.as_ptr() as *const c_char;
-        unsafe {
-            assert!(CStr::from_ptr(ptr).to_str().is_err());
-            assert_eq!(CStr::from_ptr(ptr).to_string_lossy(), Owned::<str>(format!("123\u{FFFD}")));
-        }
-    }
-
-    #[test]
-    fn to_owned() {
-        let data = b"123\0";
-        let ptr = data.as_ptr() as *const c_char;
-
-        let owned = unsafe { CStr::from_ptr(ptr).to_owned() };
-        assert_eq!(owned.as_bytes_with_nul(), data);
-    }
-
-    #[test]
-    fn equal_hash() {
-        let data = b"123\xE2\xFA\xA6\0";
-        let ptr = data.as_ptr() as *const c_char;
-        let cstr: &'static CStr = unsafe { CStr::from_ptr(ptr) };
-
-        let mut s = DefaultHasher::new();
-        cstr.hash(&mut s);
-        let cstr_hash = s.finish();
-        let mut s = DefaultHasher::new();
-        CString::new(&data[..data.len() - 1]).unwrap().hash(&mut s);
-        let cstring_hash = s.finish();
-
-        assert_eq!(cstr_hash, cstring_hash);
-    }
-
-    #[test]
-    fn from_bytes_with_nul() {
-        let data = b"123\0";
-        let cstr = CStr::from_bytes_with_nul(data);
-        assert_eq!(cstr.map(CStr::to_bytes), Ok(&b"123"[..]));
-        let cstr = CStr::from_bytes_with_nul(data);
-        assert_eq!(cstr.map(CStr::to_bytes_with_nul), Ok(&b"123\0"[..]));
-
-        unsafe {
-            let cstr = CStr::from_bytes_with_nul(data);
-            let cstr_unchecked = CStr::from_bytes_with_nul_unchecked(data);
-            assert_eq!(cstr, Ok(cstr_unchecked));
-        }
-    }
-
-    #[test]
-    fn from_bytes_with_nul_unterminated() {
-        let data = b"123";
-        let cstr = CStr::from_bytes_with_nul(data);
-        assert!(cstr.is_err());
-    }
-
-    #[test]
-    fn from_bytes_with_nul_interior() {
-        let data = b"1\023\0";
-        let cstr = CStr::from_bytes_with_nul(data);
-        assert!(cstr.is_err());
-    }
-
-    #[test]
-    fn into_boxed() {
-        let orig: &[u8] = b"Hello, world!\0";
-        let cstr = CStr::from_bytes_with_nul(orig).unwrap();
-        let boxed: Box<CStr> = Box::from(cstr);
-        let cstring = cstr.to_owned().into_boxed_c_str().into_c_string();
-        assert_eq!(cstr, &*boxed);
-        assert_eq!(&*boxed, &*cstring);
-        assert_eq!(&*cstring, cstr);
-    }
-
-    #[test]
-    fn boxed_default() {
-        let boxed = <Box<CStr>>::default();
-        assert_eq!(boxed.to_bytes_with_nul(), &[0]);
-    }
-
-    #[test]
-    fn test_c_str_clone_into() {
-        let mut c_string = CString::new("lorem").unwrap();
-        let c_ptr = c_string.as_ptr();
-        let c_str = CStr::from_bytes_with_nul(b"ipsum\0").unwrap();
-        c_str.clone_into(&mut c_string);
-        assert_eq!(c_str, c_string.as_c_str());
-        // The exact same size shouldn't have needed to move its allocation
-        assert_eq!(c_ptr, c_string.as_ptr());
-    }
-
-    #[test]
-    fn into_rc() {
-        let orig: &[u8] = b"Hello, world!\0";
-        let cstr = CStr::from_bytes_with_nul(orig).unwrap();
-        let rc: Rc<CStr> = Rc::from(cstr);
-        let arc: Arc<CStr> = Arc::from(cstr);
-
-        assert_eq!(&*rc, cstr);
-        assert_eq!(&*arc, cstr);
-
-        let rc2: Rc<CStr> = Rc::from(cstr.to_owned());
-        let arc2: Arc<CStr> = Arc::from(cstr.to_owned());
-
-        assert_eq!(&*rc2, cstr);
-        assert_eq!(&*arc2, cstr);
-    }
-
-    #[test]
-    fn cstr_const_constructor() {
-        const CSTR: &CStr = unsafe { CStr::from_bytes_with_nul_unchecked(b"Hello, world!\0") };
-
-        assert_eq!(CSTR.to_str().unwrap(), "Hello, world!");
-    }
-
-    #[test]
-    fn cstr_index_from() {
-        let original = b"Hello, world!\0";
-        let cstr = CStr::from_bytes_with_nul(original).unwrap();
-        let result = CStr::from_bytes_with_nul(&original[7..]).unwrap();
-
-        assert_eq!(&cstr[7..], result);
-    }
-
-    #[test]
-    #[should_panic]
-    fn cstr_index_from_empty() {
-        let original = b"Hello, world!\0";
-        let cstr = CStr::from_bytes_with_nul(original).unwrap();
-        let _ = &cstr[original.len()..];
-    }
-}
diff --git a/src/libstd/ffi/mod.rs b/src/libstd/ffi/mod.rs
deleted file mode 100644
index f442d7fde1a..00000000000
--- a/src/libstd/ffi/mod.rs
+++ /dev/null
@@ -1,180 +0,0 @@
-//! Utilities related to FFI bindings.
-//!
-//! This module provides utilities to handle data across non-Rust
-//! interfaces, like other programming languages and the underlying
-//! operating system. It is mainly of use for FFI (Foreign Function
-//! Interface) bindings and code that needs to exchange C-like strings
-//! with other languages.
-//!
-//! # Overview
-//!
-//! Rust represents owned strings with the [`String`] type, and
-//! borrowed slices of strings with the [`str`] primitive. Both are
-//! always in UTF-8 encoding, and may contain nul bytes in the middle,
-//! i.e., if you look at the bytes that make up the string, there may
-//! be a `\0` among them. Both `String` and `str` store their length
-//! explicitly; there are no nul terminators at the end of strings
-//! like in C.
-//!
-//! C strings are different from Rust strings:
-//!
-//! * **Encodings** - Rust strings are UTF-8, but C strings may use
-//! other encodings. If you are using a string from C, you should
-//! check its encoding explicitly, rather than just assuming that it
-//! is UTF-8 like you can do in Rust.
-//!
-//! * **Character size** - C strings may use `char` or `wchar_t`-sized
-//! characters; please **note** that C's `char` is different from Rust's.
-//! The C standard leaves the actual sizes of those types open to
-//! interpretation, but defines different APIs for strings made up of
-//! each character type. Rust strings are always UTF-8, so different
-//! Unicode characters will be encoded in a variable number of bytes
-//! each. The Rust type [`char`] represents a '[Unicode scalar
-//! value]', which is similar to, but not the same as, a '[Unicode
-//! code point]'.
-//!
-//! * **Nul terminators and implicit string lengths** - Often, C
-//! strings are nul-terminated, i.e., they have a `\0` character at the
-//! end. The length of a string buffer is not stored, but has to be
-//! calculated; to compute the length of a string, C code must
-//! manually call a function like `strlen()` for `char`-based strings,
-//! or `wcslen()` for `wchar_t`-based ones. Those functions return
-//! the number of characters in the string excluding the nul
-//! terminator, so the buffer length is really `len+1` characters.
-//! Rust strings don't have a nul terminator; their length is always
-//! stored and does not need to be calculated. While in Rust
-//! accessing a string's length is a `O(1)` operation (because the
-//! length is stored); in C it is an `O(length)` operation because the
-//! length needs to be computed by scanning the string for the nul
-//! terminator.
-//!
-//! * **Internal nul characters** - When C strings have a nul
-//! terminator character, this usually means that they cannot have nul
-//! characters in the middle — a nul character would essentially
-//! truncate the string. Rust strings *can* have nul characters in
-//! the middle, because nul does not have to mark the end of the
-//! string in Rust.
-//!
-//! # Representations of non-Rust strings
-//!
-//! [`CString`] and [`CStr`] are useful when you need to transfer
-//! UTF-8 strings to and from languages with a C ABI, like Python.
-//!
-//! * **From Rust to C:** [`CString`] represents an owned, C-friendly
-//! string: it is nul-terminated, and has no internal nul characters.
-//! Rust code can create a [`CString`] out of a normal string (provided
-//! that the string doesn't have nul characters in the middle), and
-//! then use a variety of methods to obtain a raw `*mut `[`u8`] that can
-//! then be passed as an argument to functions which use the C
-//! conventions for strings.
-//!
-//! * **From C to Rust:** [`CStr`] represents a borrowed C string; it
-//! is what you would use to wrap a raw `*const `[`u8`] that you got from
-//! a C function. A [`CStr`] is guaranteed to be a nul-terminated array
-//! of bytes. Once you have a [`CStr`], you can convert it to a Rust
-//! [`&str`][`str`] if it's valid UTF-8, or lossily convert it by adding
-//! replacement characters.
-//!
-//! [`OsString`] and [`OsStr`] are useful when you need to transfer
-//! strings to and from the operating system itself, or when capturing
-//! the output of external commands. Conversions between [`OsString`],
-//! [`OsStr`] and Rust strings work similarly to those for [`CString`]
-//! and [`CStr`].
-//!
-//! * [`OsString`] represents an owned string in whatever
-//! representation the operating system prefers. In the Rust standard
-//! library, various APIs that transfer strings to/from the operating
-//! system use [`OsString`] instead of plain strings. For example,
-//! [`env::var_os()`] is used to query environment variables; it
-//! returns an [`Option`]`<`[`OsString`]`>`. If the environment variable
-//! exists you will get a [`Some`]`(os_string)`, which you can *then* try to
-//! convert to a Rust string. This yields a [`Result<>`], so that
-//! your code can detect errors in case the environment variable did
-//! not in fact contain valid Unicode data.
-//!
-//! * [`OsStr`] represents a borrowed reference to a string in a
-//! format that can be passed to the operating system. It can be
-//! converted into an UTF-8 Rust string slice in a similar way to
-//! [`OsString`].
-//!
-//! # Conversions
-//!
-//! ## On Unix
-//!
-//! On Unix, [`OsStr`] implements the
-//! `std::os::unix::ffi::`[`OsStrExt`][unix.OsStrExt] trait, which
-//! augments it with two methods, [`from_bytes`] and [`as_bytes`].
-//! These do inexpensive conversions from and to UTF-8 byte slices.
-//!
-//! Additionally, on Unix [`OsString`] implements the
-//! `std::os::unix::ffi::`[`OsStringExt`][unix.OsStringExt] trait,
-//! which provides [`from_vec`] and [`into_vec`] methods that consume
-//! their arguments, and take or produce vectors of [`u8`].
-//!
-//! ## On Windows
-//!
-//! On Windows, [`OsStr`] implements the
-//! `std::os::windows::ffi::`[`OsStrExt`][windows.OsStrExt] trait,
-//! which provides an [`encode_wide`] method. This provides an
-//! iterator that can be [`collect`]ed into a vector of [`u16`].
-//!
-//! Additionally, on Windows [`OsString`] implements the
-//! `std::os::windows:ffi::`[`OsStringExt`][windows.OsStringExt]
-//! trait, which provides a [`from_wide`] method. The result of this
-//! method is an [`OsString`] which can be round-tripped to a Windows
-//! string losslessly.
-//!
-//! [`String`]: ../string/struct.String.html
-//! [`str`]: ../primitive.str.html
-//! [`char`]: ../primitive.char.html
-//! [`u8`]: ../primitive.u8.html
-//! [`u16`]: ../primitive.u16.html
-//! [Unicode scalar value]: http://www.unicode.org/glossary/#unicode_scalar_value
-//! [Unicode code point]: http://www.unicode.org/glossary/#code_point
-//! [`CString`]: struct.CString.html
-//! [`CStr`]: struct.CStr.html
-//! [`OsString`]: struct.OsString.html
-//! [`OsStr`]: struct.OsStr.html
-//! [`env::set_var()`]: ../env/fn.set_var.html
-//! [`env::var_os()`]: ../env/fn.var_os.html
-//! [`Result<>`]: ../result/enum.Result.html
-//! [unix.OsStringExt]: ../os/unix/ffi/trait.OsStringExt.html
-//! [`from_vec`]: ../os/unix/ffi/trait.OsStringExt.html#tymethod.from_vec
-//! [`into_vec`]: ../os/unix/ffi/trait.OsStringExt.html#tymethod.into_vec
-//! [unix.OsStrExt]: ../os/unix/ffi/trait.OsStrExt.html
-//! [`from_bytes`]: ../os/unix/ffi/trait.OsStrExt.html#tymethod.from_bytes
-//! [`as_bytes`]: ../os/unix/ffi/trait.OsStrExt.html#tymethod.as_bytes
-//! [`OsStrExt`]: ../os/unix/ffi/trait.OsStrExt.html
-//! [windows.OsStrExt]: ../os/windows/ffi/trait.OsStrExt.html
-//! [`encode_wide`]: ../os/windows/ffi/trait.OsStrExt.html#tymethod.encode_wide
-//! [`collect`]: ../iter/trait.Iterator.html#method.collect
-//! [windows.OsStringExt]: ../os/windows/ffi/trait.OsStringExt.html
-//! [`from_wide`]: ../os/windows/ffi/trait.OsStringExt.html#tymethod.from_wide
-//! [`Option`]: ../option/enum.Option.html
-//! [`Some`]: ../option/enum.Option.html#variant.Some
-
-#![stable(feature = "rust1", since = "1.0.0")]
-
-#[stable(feature = "cstr_from_bytes", since = "1.10.0")]
-pub use self::c_str::FromBytesWithNulError;
-#[unstable(feature = "cstring_from_vec_with_nul", issue = "73179")]
-pub use self::c_str::FromVecWithNulError;
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use self::c_str::{CStr, CString, IntoStringError, NulError};
-
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use self::os_str::{OsStr, OsString};
-
-#[stable(feature = "core_c_void", since = "1.30.0")]
-pub use core::ffi::c_void;
-
-#[unstable(
-    feature = "c_variadic",
-    reason = "the `c_variadic` feature has not been properly tested on \
-              all supported platforms",
-    issue = "44930"
-)]
-pub use core::ffi::{VaList, VaListImpl};
-
-mod c_str;
-mod os_str;
diff --git a/src/libstd/ffi/os_str.rs b/src/libstd/ffi/os_str.rs
deleted file mode 100644
index d1eaf3c583f..00000000000
--- a/src/libstd/ffi/os_str.rs
+++ /dev/null
@@ -1,1365 +0,0 @@
-use crate::borrow::{Borrow, Cow};
-use crate::cmp;
-use crate::fmt;
-use crate::hash::{Hash, Hasher};
-use crate::ops;
-use crate::rc::Rc;
-use crate::str::FromStr;
-use crate::sync::Arc;
-
-use crate::sys::os_str::{Buf, Slice};
-use crate::sys_common::{AsInner, FromInner, IntoInner};
-
-/// A type that can represent owned, mutable platform-native strings, but is
-/// cheaply inter-convertible with Rust strings.
-///
-/// The need for this type arises from the fact that:
-///
-/// * On Unix systems, strings are often arbitrary sequences of non-zero
-///   bytes, in many cases interpreted as UTF-8.
-///
-/// * On Windows, strings are often arbitrary sequences of non-zero 16-bit
-///   values, interpreted as UTF-16 when it is valid to do so.
-///
-/// * In Rust, strings are always valid UTF-8, which may contain zeros.
-///
-/// `OsString` and [`OsStr`] bridge this gap by simultaneously representing Rust
-/// and platform-native string values, and in particular allowing a Rust string
-/// to be converted into an "OS" string with no cost if possible. A consequence
-/// of this is that `OsString` instances are *not* `NUL` terminated; in order
-/// to pass to e.g., Unix system call, you should create a [`CStr`].
-///
-/// `OsString` is to [`&OsStr`] as [`String`] is to [`&str`]: the former
-/// in each pair are owned strings; the latter are borrowed
-/// references.
-///
-/// Note, `OsString` and [`OsStr`] internally do not necessarily hold strings in
-/// the form native to the platform; While on Unix, strings are stored as a
-/// sequence of 8-bit values, on Windows, where strings are 16-bit value based
-/// as just discussed, strings are also actually stored as a sequence of 8-bit
-/// values, encoded in a less-strict variant of UTF-8. This is useful to
-/// understand when handling capacity and length values.
-///
-/// # Creating an `OsString`
-///
-/// **From a Rust string**: `OsString` implements
-/// [`From`]`<`[`String`]`>`, so you can use `my_string.from` to
-/// create an `OsString` from a normal Rust string.
-///
-/// **From slices:** Just like you can start with an empty Rust
-/// [`String`] and then [`push_str`][String.push_str] `&str`
-/// sub-string slices into it, you can create an empty `OsString` with
-/// the [`new`] method and then push string slices into it with the
-/// [`push`] method.
-///
-/// # Extracting a borrowed reference to the whole OS string
-///
-/// You can use the [`as_os_str`] method to get an `&`[`OsStr`] from
-/// an `OsString`; this is effectively a borrowed reference to the
-/// whole string.
-///
-/// # Conversions
-///
-/// See the [module's toplevel documentation about conversions][conversions] for a discussion on
-/// the traits which `OsString` implements for [conversions] from/to native representations.
-///
-/// [`OsStr`]: struct.OsStr.html
-/// [`&OsStr`]: struct.OsStr.html
-/// [`CStr`]: struct.CStr.html
-/// [`From`]: ../convert/trait.From.html
-/// [`String`]: ../string/struct.String.html
-/// [`&str`]: ../primitive.str.html
-/// [`u8`]: ../primitive.u8.html
-/// [`u16`]: ../primitive.u16.html
-/// [String.push_str]: ../string/struct.String.html#method.push_str
-/// [`new`]: #method.new
-/// [`push`]: #method.push
-/// [`as_os_str`]: #method.as_os_str
-/// [conversions]: index.html#conversions
-#[derive(Clone)]
-#[stable(feature = "rust1", since = "1.0.0")]
-pub struct OsString {
-    inner: Buf,
-}
-
-/// Borrowed reference to an OS string (see [`OsString`]).
-///
-/// This type represents a borrowed reference to a string in the operating system's preferred
-/// representation.
-///
-/// `&OsStr` is to [`OsString`] as [`&str`] is to [`String`]: the former in each pair are borrowed
-/// references; the latter are owned strings.
-///
-/// See the [module's toplevel documentation about conversions][conversions] for a discussion on
-/// the traits which `OsStr` implements for [conversions] from/to native representations.
-///
-/// [`OsString`]: struct.OsString.html
-/// [`&str`]: ../primitive.str.html
-/// [`String`]: ../string/struct.String.html
-/// [conversions]: index.html#conversions
-#[stable(feature = "rust1", since = "1.0.0")]
-// FIXME:
-// `OsStr::from_inner` current implementation relies
-// on `OsStr` being layout-compatible with `Slice`.
-// When attribute privacy is implemented, `OsStr` should be annotated as `#[repr(transparent)]`.
-// Anyway, `OsStr` representation and layout are considered implementation detail, are
-// not documented and must not be relied upon.
-pub struct OsStr {
-    inner: Slice,
-}
-
-impl OsString {
-    /// Constructs a new empty `OsString`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ffi::OsString;
-    ///
-    /// let os_string = OsString::new();
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn new() -> OsString {
-        OsString { inner: Buf::from_string(String::new()) }
-    }
-
-    /// Converts to an [`OsStr`] slice.
-    ///
-    /// [`OsStr`]: struct.OsStr.html
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ffi::{OsString, OsStr};
-    ///
-    /// let os_string = OsString::from("foo");
-    /// let os_str = OsStr::new("foo");
-    /// assert_eq!(os_string.as_os_str(), os_str);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn as_os_str(&self) -> &OsStr {
-        self
-    }
-
-    /// Converts the `OsString` into a [`String`] if it contains valid Unicode data.
-    ///
-    /// On failure, ownership of the original `OsString` is returned.
-    ///
-    /// [`String`]: ../../std/string/struct.String.html
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ffi::OsString;
-    ///
-    /// let os_string = OsString::from("foo");
-    /// let string = os_string.into_string();
-    /// assert_eq!(string, Ok(String::from("foo")));
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn into_string(self) -> Result<String, OsString> {
-        self.inner.into_string().map_err(|buf| OsString { inner: buf })
-    }
-
-    /// Extends the string with the given [`&OsStr`] slice.
-    ///
-    /// [`&OsStr`]: struct.OsStr.html
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ffi::OsString;
-    ///
-    /// let mut os_string = OsString::from("foo");
-    /// os_string.push("bar");
-    /// assert_eq!(&os_string, "foobar");
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn push<T: AsRef<OsStr>>(&mut self, s: T) {
-        self.inner.push_slice(&s.as_ref().inner)
-    }
-
-    /// Creates a new `OsString` with the given capacity.
-    ///
-    /// The string will be able to hold exactly `capacity` length units of other
-    /// OS strings without reallocating. If `capacity` is 0, the string will not
-    /// allocate.
-    ///
-    /// See main `OsString` documentation information about encoding.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ffi::OsString;
-    ///
-    /// let mut os_string = OsString::with_capacity(10);
-    /// let capacity = os_string.capacity();
-    ///
-    /// // This push is done without reallocating
-    /// os_string.push("foo");
-    ///
-    /// assert_eq!(capacity, os_string.capacity());
-    /// ```
-    #[stable(feature = "osstring_simple_functions", since = "1.9.0")]
-    pub fn with_capacity(capacity: usize) -> OsString {
-        OsString { inner: Buf::with_capacity(capacity) }
-    }
-
-    /// Truncates the `OsString` to zero length.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ffi::OsString;
-    ///
-    /// let mut os_string = OsString::from("foo");
-    /// assert_eq!(&os_string, "foo");
-    ///
-    /// os_string.clear();
-    /// assert_eq!(&os_string, "");
-    /// ```
-    #[stable(feature = "osstring_simple_functions", since = "1.9.0")]
-    pub fn clear(&mut self) {
-        self.inner.clear()
-    }
-
-    /// Returns the capacity this `OsString` can hold without reallocating.
-    ///
-    /// See `OsString` introduction for information about encoding.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ffi::OsString;
-    ///
-    /// let os_string = OsString::with_capacity(10);
-    /// assert!(os_string.capacity() >= 10);
-    /// ```
-    #[stable(feature = "osstring_simple_functions", since = "1.9.0")]
-    pub fn capacity(&self) -> usize {
-        self.inner.capacity()
-    }
-
-    /// Reserves capacity for at least `additional` more capacity to be inserted
-    /// in the given `OsString`.
-    ///
-    /// The collection may reserve more space to avoid frequent reallocations.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ffi::OsString;
-    ///
-    /// let mut s = OsString::new();
-    /// s.reserve(10);
-    /// assert!(s.capacity() >= 10);
-    /// ```
-    #[stable(feature = "osstring_simple_functions", since = "1.9.0")]
-    pub fn reserve(&mut self, additional: usize) {
-        self.inner.reserve(additional)
-    }
-
-    /// Reserves the minimum capacity for exactly `additional` more capacity to
-    /// be inserted in the given `OsString`. Does nothing if the capacity is
-    /// already sufficient.
-    ///
-    /// Note that the allocator may give the collection more space than it
-    /// requests. Therefore, capacity can not be relied upon to be precisely
-    /// minimal. Prefer reserve if future insertions are expected.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ffi::OsString;
-    ///
-    /// let mut s = OsString::new();
-    /// s.reserve_exact(10);
-    /// assert!(s.capacity() >= 10);
-    /// ```
-    #[stable(feature = "osstring_simple_functions", since = "1.9.0")]
-    pub fn reserve_exact(&mut self, additional: usize) {
-        self.inner.reserve_exact(additional)
-    }
-
-    /// Shrinks the capacity of the `OsString` to match its length.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ffi::OsString;
-    ///
-    /// let mut s = OsString::from("foo");
-    ///
-    /// s.reserve(100);
-    /// assert!(s.capacity() >= 100);
-    ///
-    /// s.shrink_to_fit();
-    /// assert_eq!(3, s.capacity());
-    /// ```
-    #[stable(feature = "osstring_shrink_to_fit", since = "1.19.0")]
-    pub fn shrink_to_fit(&mut self) {
-        self.inner.shrink_to_fit()
-    }
-
-    /// Shrinks the capacity of the `OsString` with a lower bound.
-    ///
-    /// The capacity will remain at least as large as both the length
-    /// and the supplied value.
-    ///
-    /// Panics if the current capacity is smaller than the supplied
-    /// minimum capacity.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(shrink_to)]
-    /// use std::ffi::OsString;
-    ///
-    /// let mut s = OsString::from("foo");
-    ///
-    /// s.reserve(100);
-    /// assert!(s.capacity() >= 100);
-    ///
-    /// s.shrink_to(10);
-    /// assert!(s.capacity() >= 10);
-    /// s.shrink_to(0);
-    /// assert!(s.capacity() >= 3);
-    /// ```
-    #[inline]
-    #[unstable(feature = "shrink_to", reason = "new API", issue = "56431")]
-    pub fn shrink_to(&mut self, min_capacity: usize) {
-        self.inner.shrink_to(min_capacity)
-    }
-
-    /// Converts this `OsString` into a boxed [`OsStr`].
-    ///
-    /// [`OsStr`]: struct.OsStr.html
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ffi::{OsString, OsStr};
-    ///
-    /// let s = OsString::from("hello");
-    ///
-    /// let b: Box<OsStr> = s.into_boxed_os_str();
-    /// ```
-    #[stable(feature = "into_boxed_os_str", since = "1.20.0")]
-    pub fn into_boxed_os_str(self) -> Box<OsStr> {
-        let rw = Box::into_raw(self.inner.into_box()) as *mut OsStr;
-        unsafe { Box::from_raw(rw) }
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl From<String> for OsString {
-    /// Converts a [`String`] into a [`OsString`].
-    ///
-    /// The conversion copies the data, and includes an allocation on the heap.
-    ///
-    /// [`OsString`]: ../../std/ffi/struct.OsString.html
-    fn from(s: String) -> OsString {
-        OsString { inner: Buf::from_string(s) }
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: ?Sized + AsRef<OsStr>> From<&T> for OsString {
-    fn from(s: &T) -> OsString {
-        s.as_ref().to_os_string()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl ops::Index<ops::RangeFull> for OsString {
-    type Output = OsStr;
-
-    #[inline]
-    fn index(&self, _index: ops::RangeFull) -> &OsStr {
-        OsStr::from_inner(self.inner.as_slice())
-    }
-}
-
-#[stable(feature = "mut_osstr", since = "1.44.0")]
-impl ops::IndexMut<ops::RangeFull> for OsString {
-    #[inline]
-    fn index_mut(&mut self, _index: ops::RangeFull) -> &mut OsStr {
-        OsStr::from_inner_mut(self.inner.as_mut_slice())
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl ops::Deref for OsString {
-    type Target = OsStr;
-
-    #[inline]
-    fn deref(&self) -> &OsStr {
-        &self[..]
-    }
-}
-
-#[stable(feature = "mut_osstr", since = "1.44.0")]
-impl ops::DerefMut for OsString {
-    #[inline]
-    fn deref_mut(&mut self) -> &mut OsStr {
-        &mut self[..]
-    }
-}
-
-#[stable(feature = "osstring_default", since = "1.9.0")]
-impl Default for OsString {
-    /// Constructs an empty `OsString`.
-    #[inline]
-    fn default() -> OsString {
-        OsString::new()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl fmt::Debug for OsString {
-    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Debug::fmt(&**self, formatter)
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl PartialEq for OsString {
-    fn eq(&self, other: &OsString) -> bool {
-        &**self == &**other
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl PartialEq<str> for OsString {
-    fn eq(&self, other: &str) -> bool {
-        &**self == other
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl PartialEq<OsString> for str {
-    fn eq(&self, other: &OsString) -> bool {
-        &**other == self
-    }
-}
-
-#[stable(feature = "os_str_str_ref_eq", since = "1.29.0")]
-impl PartialEq<&str> for OsString {
-    fn eq(&self, other: &&str) -> bool {
-        **self == **other
-    }
-}
-
-#[stable(feature = "os_str_str_ref_eq", since = "1.29.0")]
-impl<'a> PartialEq<OsString> for &'a str {
-    fn eq(&self, other: &OsString) -> bool {
-        **other == **self
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl Eq for OsString {}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl PartialOrd for OsString {
-    #[inline]
-    fn partial_cmp(&self, other: &OsString) -> Option<cmp::Ordering> {
-        (&**self).partial_cmp(&**other)
-    }
-    #[inline]
-    fn lt(&self, other: &OsString) -> bool {
-        &**self < &**other
-    }
-    #[inline]
-    fn le(&self, other: &OsString) -> bool {
-        &**self <= &**other
-    }
-    #[inline]
-    fn gt(&self, other: &OsString) -> bool {
-        &**self > &**other
-    }
-    #[inline]
-    fn ge(&self, other: &OsString) -> bool {
-        &**self >= &**other
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl PartialOrd<str> for OsString {
-    #[inline]
-    fn partial_cmp(&self, other: &str) -> Option<cmp::Ordering> {
-        (&**self).partial_cmp(other)
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl Ord for OsString {
-    #[inline]
-    fn cmp(&self, other: &OsString) -> cmp::Ordering {
-        (&**self).cmp(&**other)
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl Hash for OsString {
-    #[inline]
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        (&**self).hash(state)
-    }
-}
-
-impl OsStr {
-    /// Coerces into an `OsStr` slice.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ffi::OsStr;
-    ///
-    /// let os_str = OsStr::new("foo");
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn new<S: AsRef<OsStr> + ?Sized>(s: &S) -> &OsStr {
-        s.as_ref()
-    }
-
-    #[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) }
-    }
-
-    #[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.
-        // 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) }
-    }
-
-    /// Yields a [`&str`] slice if the `OsStr` is valid Unicode.
-    ///
-    /// This conversion may entail doing a check for UTF-8 validity.
-    ///
-    /// [`&str`]: ../../std/primitive.str.html
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ffi::OsStr;
-    ///
-    /// let os_str = OsStr::new("foo");
-    /// assert_eq!(os_str.to_str(), Some("foo"));
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn to_str(&self) -> Option<&str> {
-        self.inner.to_str()
-    }
-
-    /// Converts an `OsStr` to a [`Cow`]`<`[`str`]`>`.
-    ///
-    /// Any non-Unicode sequences are replaced with
-    /// [`U+FFFD REPLACEMENT CHARACTER`][U+FFFD].
-    ///
-    /// [`Cow`]: ../../std/borrow/enum.Cow.html
-    /// [`str`]: ../../std/primitive.str.html
-    /// [U+FFFD]: ../../std/char/constant.REPLACEMENT_CHARACTER.html
-    ///
-    /// # Examples
-    ///
-    /// Calling `to_string_lossy` on an `OsStr` with invalid unicode:
-    ///
-    /// ```
-    /// // Note, due to differences in how Unix and Windows represent strings,
-    /// // we are forced to complicate this example, setting up example `OsStr`s
-    /// // with different source data and via different platform extensions.
-    /// // Understand that in reality you could end up with such example invalid
-    /// // sequences simply through collecting user command line arguments, for
-    /// // example.
-    ///
-    /// #[cfg(any(unix, target_os = "redox"))] {
-    ///     use std::ffi::OsStr;
-    ///     use std::os::unix::ffi::OsStrExt;
-    ///
-    ///     // Here, the values 0x66 and 0x6f correspond to 'f' and 'o'
-    ///     // respectively. The value 0x80 is a lone continuation byte, invalid
-    ///     // in a UTF-8 sequence.
-    ///     let source = [0x66, 0x6f, 0x80, 0x6f];
-    ///     let os_str = OsStr::from_bytes(&source[..]);
-    ///
-    ///     assert_eq!(os_str.to_string_lossy(), "fo�o");
-    /// }
-    /// #[cfg(windows)] {
-    ///     use std::ffi::OsString;
-    ///     use std::os::windows::prelude::*;
-    ///
-    ///     // Here the values 0x0066 and 0x006f correspond to 'f' and 'o'
-    ///     // respectively. The value 0xD800 is a lone surrogate half, invalid
-    ///     // in a UTF-16 sequence.
-    ///     let source = [0x0066, 0x006f, 0xD800, 0x006f];
-    ///     let os_string = OsString::from_wide(&source[..]);
-    ///     let os_str = os_string.as_os_str();
-    ///
-    ///     assert_eq!(os_str.to_string_lossy(), "fo�o");
-    /// }
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn to_string_lossy(&self) -> Cow<'_, str> {
-        self.inner.to_string_lossy()
-    }
-
-    /// Copies the slice into an owned [`OsString`].
-    ///
-    /// [`OsString`]: struct.OsString.html
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ffi::{OsStr, OsString};
-    ///
-    /// let os_str = OsStr::new("foo");
-    /// let os_string = os_str.to_os_string();
-    /// assert_eq!(os_string, OsString::from("foo"));
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn to_os_string(&self) -> OsString {
-        OsString { inner: self.inner.to_owned() }
-    }
-
-    /// Checks whether the `OsStr` is empty.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ffi::OsStr;
-    ///
-    /// let os_str = OsStr::new("");
-    /// assert!(os_str.is_empty());
-    ///
-    /// let os_str = OsStr::new("foo");
-    /// assert!(!os_str.is_empty());
-    /// ```
-    #[stable(feature = "osstring_simple_functions", since = "1.9.0")]
-    #[inline]
-    pub fn is_empty(&self) -> bool {
-        self.inner.inner.is_empty()
-    }
-
-    /// Returns the length of this `OsStr`.
-    ///
-    /// Note that this does **not** return the number of bytes in the string in
-    /// OS string form.
-    ///
-    /// The length returned is that of the underlying storage used by `OsStr`.
-    /// As discussed in the [`OsString`] introduction, [`OsString`] and `OsStr`
-    /// store strings in a form best suited for cheap inter-conversion between
-    /// native-platform and Rust string forms, which may differ significantly
-    /// from both of them, including in storage size and encoding.
-    ///
-    /// This number is simply useful for passing to other methods, like
-    /// [`OsString::with_capacity`] to avoid reallocations.
-    ///
-    /// [`OsString`]: struct.OsString.html
-    /// [`OsString::with_capacity`]: struct.OsString.html#method.with_capacity
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ffi::OsStr;
-    ///
-    /// let os_str = OsStr::new("");
-    /// assert_eq!(os_str.len(), 0);
-    ///
-    /// let os_str = OsStr::new("foo");
-    /// assert_eq!(os_str.len(), 3);
-    /// ```
-    #[stable(feature = "osstring_simple_functions", since = "1.9.0")]
-    pub fn len(&self) -> usize {
-        self.inner.inner.len()
-    }
-
-    /// Converts a [`Box`]`<OsStr>` into an [`OsString`] without copying or allocating.
-    ///
-    /// [`Box`]: ../boxed/struct.Box.html
-    /// [`OsString`]: struct.OsString.html
-    #[stable(feature = "into_boxed_os_str", since = "1.20.0")]
-    pub fn into_os_string(self: Box<OsStr>) -> OsString {
-        let boxed = unsafe { Box::from_raw(Box::into_raw(self) as *mut Slice) };
-        OsString { inner: Buf::from_box(boxed) }
-    }
-
-    /// Gets the underlying byte representation.
-    ///
-    /// Note: it is *crucial* that this API is private, to avoid
-    /// revealing the internal, platform-specific encodings.
-    #[inline]
-    fn bytes(&self) -> &[u8] {
-        unsafe { &*(&self.inner as *const _ as *const [u8]) }
-    }
-
-    /// Converts this string to its ASCII lower case equivalent in-place.
-    ///
-    /// ASCII letters 'A' to 'Z' are mapped to 'a' to 'z',
-    /// but non-ASCII letters are unchanged.
-    ///
-    /// To return a new lowercased value without modifying the existing one, use
-    /// [`to_ascii_lowercase`].
-    ///
-    /// [`to_ascii_lowercase`]: #method.to_ascii_lowercase
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(osstring_ascii)]
-    /// use std::ffi::OsString;
-    ///
-    /// let mut s = OsString::from("GRÜßE, JÜRGEN ❤");
-    ///
-    /// s.make_ascii_lowercase();
-    ///
-    /// assert_eq!("grÜße, jÜrgen ❤", s);
-    /// ```
-    #[unstable(feature = "osstring_ascii", issue = "70516")]
-    pub fn make_ascii_lowercase(&mut self) {
-        self.inner.make_ascii_lowercase()
-    }
-
-    /// Converts this string to its ASCII upper case equivalent in-place.
-    ///
-    /// ASCII letters 'a' to 'z' are mapped to 'A' to 'Z',
-    /// but non-ASCII letters are unchanged.
-    ///
-    /// To return a new uppercased value without modifying the existing one, use
-    /// [`to_ascii_uppercase`].
-    ///
-    /// [`to_ascii_uppercase`]: #method.to_ascii_uppercase
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(osstring_ascii)]
-    /// use std::ffi::OsString;
-    ///
-    /// let mut s = OsString::from("Grüße, Jürgen ❤");
-    ///
-    /// s.make_ascii_uppercase();
-    ///
-    /// assert_eq!("GRüßE, JüRGEN ❤", s);
-    /// ```
-    #[unstable(feature = "osstring_ascii", issue = "70516")]
-    pub fn make_ascii_uppercase(&mut self) {
-        self.inner.make_ascii_uppercase()
-    }
-
-    /// Returns a copy of this string where each character is mapped to its
-    /// ASCII lower case equivalent.
-    ///
-    /// ASCII letters 'A' to 'Z' are mapped to 'a' to 'z',
-    /// but non-ASCII letters are unchanged.
-    ///
-    /// To lowercase the value in-place, use [`make_ascii_lowercase`].
-    ///
-    /// [`make_ascii_lowercase`]: #method.make_ascii_lowercase
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(osstring_ascii)]
-    /// use std::ffi::OsString;
-    /// let s = OsString::from("Grüße, Jürgen ❤");
-    ///
-    /// assert_eq!("grüße, jürgen ❤", s.to_ascii_lowercase());
-    /// ```
-    #[unstable(feature = "osstring_ascii", issue = "70516")]
-    pub fn to_ascii_lowercase(&self) -> OsString {
-        OsString::from_inner(self.inner.to_ascii_lowercase())
-    }
-
-    /// Returns a copy of this string where each character is mapped to its
-    /// ASCII upper case equivalent.
-    ///
-    /// ASCII letters 'a' to 'z' are mapped to 'A' to 'Z',
-    /// but non-ASCII letters are unchanged.
-    ///
-    /// To uppercase the value in-place, use [`make_ascii_uppercase`].
-    ///
-    /// [`make_ascii_uppercase`]: #method.make_ascii_uppercase
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(osstring_ascii)]
-    /// use std::ffi::OsString;
-    /// let s = OsString::from("Grüße, Jürgen ❤");
-    ///
-    /// assert_eq!("GRüßE, JüRGEN ❤", s.to_ascii_uppercase());
-    /// ```
-    #[unstable(feature = "osstring_ascii", issue = "70516")]
-    pub fn to_ascii_uppercase(&self) -> OsString {
-        OsString::from_inner(self.inner.to_ascii_uppercase())
-    }
-
-    /// Checks if all characters in this string are within the ASCII range.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(osstring_ascii)]
-    /// use std::ffi::OsString;
-    ///
-    /// let ascii = OsString::from("hello!\n");
-    /// let non_ascii = OsString::from("Grüße, Jürgen ❤");
-    ///
-    /// assert!(ascii.is_ascii());
-    /// assert!(!non_ascii.is_ascii());
-    /// ```
-    #[unstable(feature = "osstring_ascii", issue = "70516")]
-    pub fn is_ascii(&self) -> bool {
-        self.inner.is_ascii()
-    }
-
-    /// Checks that two strings are an ASCII case-insensitive match.
-    ///
-    /// Same as `to_ascii_lowercase(a) == to_ascii_lowercase(b)`,
-    /// but without allocating and copying temporaries.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(osstring_ascii)]
-    /// use std::ffi::OsString;
-    ///
-    /// assert!(OsString::from("Ferris").eq_ignore_ascii_case("FERRIS"));
-    /// assert!(OsString::from("Ferrös").eq_ignore_ascii_case("FERRöS"));
-    /// assert!(!OsString::from("Ferrös").eq_ignore_ascii_case("FERRÖS"));
-    /// ```
-    #[unstable(feature = "osstring_ascii", issue = "70516")]
-    pub fn eq_ignore_ascii_case<S: ?Sized + AsRef<OsStr>>(&self, other: &S) -> bool {
-        self.inner.eq_ignore_ascii_case(&other.as_ref().inner)
-    }
-}
-
-#[stable(feature = "box_from_os_str", since = "1.17.0")]
-impl From<&OsStr> for Box<OsStr> {
-    fn from(s: &OsStr) -> Box<OsStr> {
-        let rw = Box::into_raw(s.inner.into_box()) as *mut OsStr;
-        unsafe { Box::from_raw(rw) }
-    }
-}
-
-#[stable(feature = "box_from_cow", since = "1.45.0")]
-impl From<Cow<'_, OsStr>> for Box<OsStr> {
-    #[inline]
-    fn from(cow: Cow<'_, OsStr>) -> Box<OsStr> {
-        match cow {
-            Cow::Borrowed(s) => Box::from(s),
-            Cow::Owned(s) => Box::from(s),
-        }
-    }
-}
-
-#[stable(feature = "os_string_from_box", since = "1.18.0")]
-impl From<Box<OsStr>> for OsString {
-    /// Converts a [`Box`]`<`[`OsStr`]`>` into a `OsString` without copying or
-    /// allocating.
-    ///
-    /// [`Box`]: ../boxed/struct.Box.html
-    /// [`OsStr`]: ../ffi/struct.OsStr.html
-    fn from(boxed: Box<OsStr>) -> OsString {
-        boxed.into_os_string()
-    }
-}
-
-#[stable(feature = "box_from_os_string", since = "1.20.0")]
-impl From<OsString> for Box<OsStr> {
-    /// Converts a [`OsString`] into a [`Box`]`<OsStr>` without copying or allocating.
-    ///
-    /// [`Box`]: ../boxed/struct.Box.html
-    /// [`OsString`]: ../ffi/struct.OsString.html
-    fn from(s: OsString) -> Box<OsStr> {
-        s.into_boxed_os_str()
-    }
-}
-
-#[stable(feature = "more_box_slice_clone", since = "1.29.0")]
-impl Clone for Box<OsStr> {
-    #[inline]
-    fn clone(&self) -> Self {
-        self.to_os_string().into_boxed_os_str()
-    }
-}
-
-#[stable(feature = "shared_from_slice2", since = "1.24.0")]
-impl From<OsString> for Arc<OsStr> {
-    /// Converts a [`OsString`] into a [`Arc`]`<OsStr>` without copying or allocating.
-    ///
-    /// [`Arc`]: ../sync/struct.Arc.html
-    /// [`OsString`]: ../ffi/struct.OsString.html
-    #[inline]
-    fn from(s: OsString) -> Arc<OsStr> {
-        let arc = s.inner.into_arc();
-        unsafe { Arc::from_raw(Arc::into_raw(arc) as *const OsStr) }
-    }
-}
-
-#[stable(feature = "shared_from_slice2", since = "1.24.0")]
-impl From<&OsStr> for Arc<OsStr> {
-    #[inline]
-    fn from(s: &OsStr) -> Arc<OsStr> {
-        let arc = s.inner.into_arc();
-        unsafe { Arc::from_raw(Arc::into_raw(arc) as *const OsStr) }
-    }
-}
-
-#[stable(feature = "shared_from_slice2", since = "1.24.0")]
-impl From<OsString> for Rc<OsStr> {
-    /// Converts a [`OsString`] into a [`Rc`]`<OsStr>` without copying or allocating.
-    ///
-    /// [`Rc`]: ../rc/struct.Rc.html
-    /// [`OsString`]: ../ffi/struct.OsString.html
-    #[inline]
-    fn from(s: OsString) -> Rc<OsStr> {
-        let rc = s.inner.into_rc();
-        unsafe { Rc::from_raw(Rc::into_raw(rc) as *const OsStr) }
-    }
-}
-
-#[stable(feature = "shared_from_slice2", since = "1.24.0")]
-impl From<&OsStr> for Rc<OsStr> {
-    #[inline]
-    fn from(s: &OsStr) -> Rc<OsStr> {
-        let rc = s.inner.into_rc();
-        unsafe { Rc::from_raw(Rc::into_raw(rc) as *const OsStr) }
-    }
-}
-
-#[stable(feature = "cow_from_osstr", since = "1.28.0")]
-impl<'a> From<OsString> for Cow<'a, OsStr> {
-    #[inline]
-    fn from(s: OsString) -> Cow<'a, OsStr> {
-        Cow::Owned(s)
-    }
-}
-
-#[stable(feature = "cow_from_osstr", since = "1.28.0")]
-impl<'a> From<&'a OsStr> for Cow<'a, OsStr> {
-    #[inline]
-    fn from(s: &'a OsStr) -> Cow<'a, OsStr> {
-        Cow::Borrowed(s)
-    }
-}
-
-#[stable(feature = "cow_from_osstr", since = "1.28.0")]
-impl<'a> From<&'a OsString> for Cow<'a, OsStr> {
-    #[inline]
-    fn from(s: &'a OsString) -> Cow<'a, OsStr> {
-        Cow::Borrowed(s.as_os_str())
-    }
-}
-
-#[stable(feature = "osstring_from_cow_osstr", since = "1.28.0")]
-impl<'a> From<Cow<'a, OsStr>> for OsString {
-    #[inline]
-    fn from(s: Cow<'a, OsStr>) -> Self {
-        s.into_owned()
-    }
-}
-
-#[stable(feature = "box_default_extra", since = "1.17.0")]
-impl Default for Box<OsStr> {
-    fn default() -> Box<OsStr> {
-        let rw = Box::into_raw(Slice::empty_box()) as *mut OsStr;
-        unsafe { Box::from_raw(rw) }
-    }
-}
-
-#[stable(feature = "osstring_default", since = "1.9.0")]
-impl Default for &OsStr {
-    /// Creates an empty `OsStr`.
-    #[inline]
-    fn default() -> Self {
-        OsStr::new("")
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl PartialEq for OsStr {
-    #[inline]
-    fn eq(&self, other: &OsStr) -> bool {
-        self.bytes().eq(other.bytes())
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl PartialEq<str> for OsStr {
-    #[inline]
-    fn eq(&self, other: &str) -> bool {
-        *self == *OsStr::new(other)
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl PartialEq<OsStr> for str {
-    #[inline]
-    fn eq(&self, other: &OsStr) -> bool {
-        *other == *OsStr::new(self)
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl Eq for OsStr {}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl PartialOrd for OsStr {
-    #[inline]
-    fn partial_cmp(&self, other: &OsStr) -> Option<cmp::Ordering> {
-        self.bytes().partial_cmp(other.bytes())
-    }
-    #[inline]
-    fn lt(&self, other: &OsStr) -> bool {
-        self.bytes().lt(other.bytes())
-    }
-    #[inline]
-    fn le(&self, other: &OsStr) -> bool {
-        self.bytes().le(other.bytes())
-    }
-    #[inline]
-    fn gt(&self, other: &OsStr) -> bool {
-        self.bytes().gt(other.bytes())
-    }
-    #[inline]
-    fn ge(&self, other: &OsStr) -> bool {
-        self.bytes().ge(other.bytes())
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl PartialOrd<str> for OsStr {
-    #[inline]
-    fn partial_cmp(&self, other: &str) -> Option<cmp::Ordering> {
-        self.partial_cmp(OsStr::new(other))
-    }
-}
-
-// FIXME (#19470): cannot provide PartialOrd<OsStr> for str until we
-// have more flexible coherence rules.
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl Ord for OsStr {
-    #[inline]
-    fn cmp(&self, other: &OsStr) -> cmp::Ordering {
-        self.bytes().cmp(other.bytes())
-    }
-}
-
-macro_rules! impl_cmp {
-    ($lhs:ty, $rhs: ty) => {
-        #[stable(feature = "cmp_os_str", since = "1.8.0")]
-        impl<'a, 'b> PartialEq<$rhs> for $lhs {
-            #[inline]
-            fn eq(&self, other: &$rhs) -> bool {
-                <OsStr as PartialEq>::eq(self, other)
-            }
-        }
-
-        #[stable(feature = "cmp_os_str", since = "1.8.0")]
-        impl<'a, 'b> PartialEq<$lhs> for $rhs {
-            #[inline]
-            fn eq(&self, other: &$lhs) -> bool {
-                <OsStr as PartialEq>::eq(self, other)
-            }
-        }
-
-        #[stable(feature = "cmp_os_str", since = "1.8.0")]
-        impl<'a, 'b> PartialOrd<$rhs> for $lhs {
-            #[inline]
-            fn partial_cmp(&self, other: &$rhs) -> Option<cmp::Ordering> {
-                <OsStr as PartialOrd>::partial_cmp(self, other)
-            }
-        }
-
-        #[stable(feature = "cmp_os_str", since = "1.8.0")]
-        impl<'a, 'b> PartialOrd<$lhs> for $rhs {
-            #[inline]
-            fn partial_cmp(&self, other: &$lhs) -> Option<cmp::Ordering> {
-                <OsStr as PartialOrd>::partial_cmp(self, other)
-            }
-        }
-    };
-}
-
-impl_cmp!(OsString, OsStr);
-impl_cmp!(OsString, &'a OsStr);
-impl_cmp!(Cow<'a, OsStr>, OsStr);
-impl_cmp!(Cow<'a, OsStr>, &'b OsStr);
-impl_cmp!(Cow<'a, OsStr>, OsString);
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl Hash for OsStr {
-    #[inline]
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.bytes().hash(state)
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl fmt::Debug for OsStr {
-    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Debug::fmt(&self.inner, formatter)
-    }
-}
-
-impl OsStr {
-    pub(crate) fn display(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Display::fmt(&self.inner, formatter)
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl Borrow<OsStr> for OsString {
-    fn borrow(&self) -> &OsStr {
-        &self[..]
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl ToOwned for OsStr {
-    type Owned = OsString;
-    fn to_owned(&self) -> OsString {
-        self.to_os_string()
-    }
-    fn clone_into(&self, target: &mut OsString) {
-        self.inner.clone_into(&mut target.inner)
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl AsRef<OsStr> for OsStr {
-    fn as_ref(&self) -> &OsStr {
-        self
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl AsRef<OsStr> for OsString {
-    #[inline]
-    fn as_ref(&self) -> &OsStr {
-        self
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl AsRef<OsStr> for str {
-    #[inline]
-    fn as_ref(&self) -> &OsStr {
-        OsStr::from_inner(Slice::from_str(self))
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl AsRef<OsStr> for String {
-    #[inline]
-    fn as_ref(&self) -> &OsStr {
-        (&**self).as_ref()
-    }
-}
-
-impl FromInner<Buf> for OsString {
-    fn from_inner(buf: Buf) -> OsString {
-        OsString { inner: buf }
-    }
-}
-
-impl IntoInner<Buf> for OsString {
-    fn into_inner(self) -> Buf {
-        self.inner
-    }
-}
-
-impl AsInner<Slice> for OsStr {
-    #[inline]
-    fn as_inner(&self) -> &Slice {
-        &self.inner
-    }
-}
-
-#[stable(feature = "osstring_from_str", since = "1.45.0")]
-impl FromStr for OsString {
-    type Err = core::convert::Infallible;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        Ok(OsString::from(s))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::sys_common::{AsInner, IntoInner};
-
-    use crate::rc::Rc;
-    use crate::sync::Arc;
-
-    #[test]
-    fn test_os_string_with_capacity() {
-        let os_string = OsString::with_capacity(0);
-        assert_eq!(0, os_string.inner.into_inner().capacity());
-
-        let os_string = OsString::with_capacity(10);
-        assert_eq!(10, os_string.inner.into_inner().capacity());
-
-        let mut os_string = OsString::with_capacity(0);
-        os_string.push("abc");
-        assert!(os_string.inner.into_inner().capacity() >= 3);
-    }
-
-    #[test]
-    fn test_os_string_clear() {
-        let mut os_string = OsString::from("abc");
-        assert_eq!(3, os_string.inner.as_inner().len());
-
-        os_string.clear();
-        assert_eq!(&os_string, "");
-        assert_eq!(0, os_string.inner.as_inner().len());
-    }
-
-    #[test]
-    fn test_os_string_capacity() {
-        let os_string = OsString::with_capacity(0);
-        assert_eq!(0, os_string.capacity());
-
-        let os_string = OsString::with_capacity(10);
-        assert_eq!(10, os_string.capacity());
-
-        let mut os_string = OsString::with_capacity(0);
-        os_string.push("abc");
-        assert!(os_string.capacity() >= 3);
-    }
-
-    #[test]
-    fn test_os_string_reserve() {
-        let mut os_string = OsString::new();
-        assert_eq!(os_string.capacity(), 0);
-
-        os_string.reserve(2);
-        assert!(os_string.capacity() >= 2);
-
-        for _ in 0..16 {
-            os_string.push("a");
-        }
-
-        assert!(os_string.capacity() >= 16);
-        os_string.reserve(16);
-        assert!(os_string.capacity() >= 32);
-
-        os_string.push("a");
-
-        os_string.reserve(16);
-        assert!(os_string.capacity() >= 33)
-    }
-
-    #[test]
-    fn test_os_string_reserve_exact() {
-        let mut os_string = OsString::new();
-        assert_eq!(os_string.capacity(), 0);
-
-        os_string.reserve_exact(2);
-        assert!(os_string.capacity() >= 2);
-
-        for _ in 0..16 {
-            os_string.push("a");
-        }
-
-        assert!(os_string.capacity() >= 16);
-        os_string.reserve_exact(16);
-        assert!(os_string.capacity() >= 32);
-
-        os_string.push("a");
-
-        os_string.reserve_exact(16);
-        assert!(os_string.capacity() >= 33)
-    }
-
-    #[test]
-    fn test_os_string_default() {
-        let os_string: OsString = Default::default();
-        assert_eq!("", &os_string);
-    }
-
-    #[test]
-    fn test_os_str_is_empty() {
-        let mut os_string = OsString::new();
-        assert!(os_string.is_empty());
-
-        os_string.push("abc");
-        assert!(!os_string.is_empty());
-
-        os_string.clear();
-        assert!(os_string.is_empty());
-    }
-
-    #[test]
-    fn test_os_str_len() {
-        let mut os_string = OsString::new();
-        assert_eq!(0, os_string.len());
-
-        os_string.push("abc");
-        assert_eq!(3, os_string.len());
-
-        os_string.clear();
-        assert_eq!(0, os_string.len());
-    }
-
-    #[test]
-    fn test_os_str_default() {
-        let os_str: &OsStr = Default::default();
-        assert_eq!("", os_str);
-    }
-
-    #[test]
-    fn into_boxed() {
-        let orig = "Hello, world!";
-        let os_str = OsStr::new(orig);
-        let boxed: Box<OsStr> = Box::from(os_str);
-        let os_string = os_str.to_owned().into_boxed_os_str().into_os_string();
-        assert_eq!(os_str, &*boxed);
-        assert_eq!(&*boxed, &*os_string);
-        assert_eq!(&*os_string, os_str);
-    }
-
-    #[test]
-    fn boxed_default() {
-        let boxed = <Box<OsStr>>::default();
-        assert!(boxed.is_empty());
-    }
-
-    #[test]
-    fn test_os_str_clone_into() {
-        let mut os_string = OsString::with_capacity(123);
-        os_string.push("hello");
-        let os_str = OsStr::new("bonjour");
-        os_str.clone_into(&mut os_string);
-        assert_eq!(os_str, os_string);
-        assert!(os_string.capacity() >= 123);
-    }
-
-    #[test]
-    fn into_rc() {
-        let orig = "Hello, world!";
-        let os_str = OsStr::new(orig);
-        let rc: Rc<OsStr> = Rc::from(os_str);
-        let arc: Arc<OsStr> = Arc::from(os_str);
-
-        assert_eq!(&*rc, os_str);
-        assert_eq!(&*arc, os_str);
-
-        let rc2: Rc<OsStr> = Rc::from(os_str.to_owned());
-        let arc2: Arc<OsStr> = Arc::from(os_str.to_owned());
-
-        assert_eq!(&*rc2, os_str);
-        assert_eq!(&*arc2, os_str);
-    }
-}