Add parameter for CString, OsString, and PathBuf

Author: TimDiekmann

src/libstd/ffi/c_str.rs

@@ -1,8 +1,10 @@
+use crate::alloc::{AllocRef, Global};
 use crate::ascii;
 use crate::borrow::{Borrow, Cow};
 use crate::cmp::Ordering;
 use crate::error::Error;
 use crate::fmt::{self, Write};
+use crate::hash;
 use crate::io;
 use crate::mem;
 use crate::memchr;
@@ -114,13 +116,55 @@ use crate::sys;
 /// 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 {
+pub struct CString<A: AllocRef = Global> {
     // 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]>,
+    inner: Box<[u8], A>,
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl PartialEq for CString {
+    #[inline]
+    fn eq(&self, other: &Self) -> bool {
+        self.inner.eq(&other.inner)
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl Eq for CString {}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl PartialOrd for CString {
+    #[inline]
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        self.inner.partial_cmp(&other.inner)
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl Ord for CString {
+    #[inline]
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.inner.cmp(&other.inner)
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl hash::Hash for CString {
+    #[inline]
+    fn hash<H: hash::Hasher>(&self, state: &mut H) {
+        self.inner.hash(state)
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl Clone for CString {
+    #[inline]
+    fn clone(&self) -> Self {
+        Self { inner: self.inner.clone() }
+    }
 }
 
 /// Representation of a borrowed C string.
@@ -638,7 +682,7 @@ impl CString {
 // 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 {
+impl<A: AllocRef> Drop for CString<A> {
     #[inline]
     fn drop(&mut self) {
         unsafe {

src/libstd/ffi/os_str.rs

@@ -1,3 +1,4 @@
+use crate::alloc::{AllocRef, Global};
 use crate::borrow::{Borrow, Cow};
 use crate::cmp;
 use crate::fmt;
@@ -75,10 +76,17 @@ use crate::sys_common::{AsInner, FromInner, IntoInner};
 /// [`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,
+pub struct OsString<A: AllocRef = Global> {
+    inner: Buf<A>,
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl Clone for OsString {
+    #[inline]
+    fn clone(&self) -> Self {
+        Self { inner: self.inner.clone() }
+    }
 }
 
 /// Borrowed reference to an OS string (see [`OsString`]).
@@ -1155,14 +1163,14 @@ impl AsRef<OsStr> for String {
     }
 }
 
-impl FromInner<Buf> for OsString {
-    fn from_inner(buf: Buf) -> OsString {
-        OsString { inner: buf }
+impl<A: AllocRef> FromInner<Buf<A>> for OsString<A> {
+    fn from_inner(buf: Buf<A>) -> OsString<A> {
+        Self { inner: buf }
     }
 }
 
-impl IntoInner<Buf> for OsString {
-    fn into_inner(self) -> Buf {
+impl<A: AllocRef> IntoInner<Buf<A>> for OsString<A> {
+    fn into_inner(self) -> Buf<A> {
         self.inner
     }
 }

src/libstd/path.rs

@@ -69,6 +69,7 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
+use crate::alloc::{AllocRef, Global};
 use crate::borrow::{Borrow, Cow};
 use crate::cmp;
 use crate::error::Error;
@@ -1079,16 +1080,23 @@ impl FusedIterator for Ancestors<'_> {}
 /// ```
 ///
 /// Which method works best depends on what kind of situation you're in.
-#[derive(Clone)]
 #[stable(feature = "rust1", since = "1.0.0")]
 // FIXME:
 // `PathBuf::as_mut_vec` current implementation relies
 // on `PathBuf` being layout-compatible with `Vec<u8>`.
 // When attribute privacy is implemented, `PathBuf` should be annotated as `#[repr(transparent)]`.
 // Anyway, `PathBuf` representation and layout are considered implementation detail, are
 // not documented and must not be relied upon.
-pub struct PathBuf {
-    inner: OsString,
+pub struct PathBuf<A: AllocRef = Global> {
+    inner: OsString<A>,
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl Clone for PathBuf {
+    #[inline]
+    fn clone(&self) -> Self {
+        Self { inner: self.inner.clone() }
+    }
 }
 
 impl PathBuf {

src/libstd/sys_common/os_str_bytes.rs

@@ -1,9 +1,11 @@
 //! The underlying OsString/OsStr implementation on Unix and many other
 //! systems: just a `Vec<u8>`/`[u8]`.
 
+use crate::alloc::{AllocRef, Global};
 use crate::borrow::Cow;
 use crate::ffi::{OsStr, OsString};
 use crate::fmt;
+use crate::hash;
 use crate::mem;
 use crate::rc::Rc;
 use crate::str;
@@ -13,9 +15,22 @@ use crate::sys_common::{AsInner, FromInner, IntoInner};
 
 use core::str::lossy::Utf8Lossy;
 
-#[derive(Clone, Hash)]
-pub(crate) struct Buf {
-    pub inner: Vec<u8>,
+pub(crate) struct Buf<A: AllocRef = Global> {
+    pub inner: Vec<u8, A>,
+}
+
+impl Clone for Buf {
+    #[inline]
+    fn clone(&self) -> Self {
+        Self { inner: self.inner.clone() }
+    }
+}
+
+impl hash::Hash for Buf {
+    #[inline]
+    fn hash<H: hash::Hasher>(&self, state: &mut H) {
+        self.inner.hash(state)
+    }
 }
 
 // FIXME:

src/test/ui/conversion-methods.stderr

@@ -20,6 +20,9 @@ LL |     let _just_to_make_bliss: PathBuf = Path::new("/ern/her/own/surprise");
    |                              |         expected struct `std::path::PathBuf`, found `&std::path::Path`
    |                              |         help: try using a conversion method: `Path::new("/ern/her/own/surprise").to_path_buf()`
    |                              expected due to this
+   |
+   = note: expected struct `std::path::PathBuf`
+           found reference `&std::path::Path`
 
 error[E0308]: mismatched types
   --> $DIR/conversion-methods.rs:9:40