Add PathLike trait

Replace `AsRef<Path>` with a `PathLike` trait.

Author: ChrisDenton

library/std/src/env.rs

@@ -17,7 +17,9 @@ use crate::error::Error;
 use crate::ffi::{OsStr, OsString};
 use crate::fmt;
 use crate::io;
-use crate::path::{Path, PathBuf};
+#[cfg(doc)]
+use crate::path::Path;
+use crate::path::{PathBuf, PathLike};
 use crate::sys;
 use crate::sys::os as os_imp;
 
@@ -80,8 +82,8 @@ pub fn current_dir() -> io::Result<PathBuf> {
 /// ```
 #[doc(alias = "chdir")]
 #[stable(feature = "env", since = "1.0.0")]
-pub fn set_current_dir<P: AsRef<Path>>(path: P) -> io::Result<()> {
-    os_imp::chdir(path.as_ref())
+pub fn set_current_dir<P: PathLike>(path: P) -> io::Result<()> {
+    path.with_path(os_imp::chdir)
 }
 
 /// An iterator over a snapshot of the environment variables of this process.

library/std/src/fs.rs

@@ -14,7 +14,7 @@ mod tests;
 use crate::ffi::OsString;
 use crate::fmt;
 use crate::io::{self, BorrowedCursor, IoSlice, IoSliceMut, Read, Seek, SeekFrom, Write};
-use crate::path::{Path, PathBuf};
+use crate::path::{NativePath, Path, PathBuf, PathLike};
 use crate::sys::fs as fs_imp;
 use crate::sys_common::{AsInner, AsInnerMut, FromInner, IntoInner};
 use crate::time::SystemTime;
@@ -246,15 +246,15 @@ pub struct DirBuilder {
 /// }
 /// ```
 #[stable(feature = "fs_read_write_bytes", since = "1.26.0")]
-pub fn read<P: AsRef<Path>>(path: P) -> io::Result<Vec<u8>> {
+pub fn read<P: PathLike>(path: P) -> io::Result<Vec<u8>> {
     fn inner(path: &Path) -> io::Result<Vec<u8>> {
         let mut file = File::open(path)?;
         let size = file.metadata().map(|m| m.len()).unwrap_or(0);
         let mut bytes = Vec::with_capacity(size as usize);
         io::default_read_to_end(&mut file, &mut bytes)?;
         Ok(bytes)
     }
-    inner(path.as_ref())
+    path.with_path(inner)
 }
 
 /// Read the entire contents of a file into a string.
@@ -286,15 +286,15 @@ pub fn read<P: AsRef<Path>>(path: P) -> io::Result<Vec<u8>> {
 /// }
 /// ```
 #[stable(feature = "fs_read_write", since = "1.26.0")]
-pub fn read_to_string<P: AsRef<Path>>(path: P) -> io::Result<String> {
+pub fn read_to_string<P: PathLike>(path: P) -> io::Result<String> {
     fn inner(path: &Path) -> io::Result<String> {
         let mut file = File::open(path)?;
         let size = file.metadata().map(|m| m.len()).unwrap_or(0);
         let mut string = String::with_capacity(size as usize);
         io::default_read_to_string(&mut file, &mut string)?;
         Ok(string)
     }
-    inner(path.as_ref())
+    path.with_path(inner)
 }
 
 /// Write a slice as the entire contents of a file.
@@ -322,11 +322,11 @@ pub fn read_to_string<P: AsRef<Path>>(path: P) -> io::Result<String> {
 /// }
 /// ```
 #[stable(feature = "fs_read_write_bytes", since = "1.26.0")]
-pub fn write<P: AsRef<Path>, C: AsRef<[u8]>>(path: P, contents: C) -> io::Result<()> {
+pub fn write<P: PathLike, C: AsRef<[u8]>>(path: P, contents: C) -> io::Result<()> {
     fn inner(path: &Path, contents: &[u8]) -> io::Result<()> {
         File::create(path)?.write_all(contents)
     }
-    inner(path.as_ref(), contents.as_ref())
+    path.with_path(|path| inner(path.as_ref(), contents.as_ref()))
 }
 
 impl File {
@@ -357,8 +357,8 @@ impl File {
     /// }
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn open<P: AsRef<Path>>(path: P) -> io::Result<File> {
-        OpenOptions::new().read(true).open(path.as_ref())
+    pub fn open<P: PathLike>(path: P) -> io::Result<File> {
+        OpenOptions::new().read(true).open(path)
     }
 
     /// Opens a file in write-only mode.
@@ -386,8 +386,8 @@ impl File {
     /// }
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn create<P: AsRef<Path>>(path: P) -> io::Result<File> {
-        OpenOptions::new().write(true).create(true).truncate(true).open(path.as_ref())
+    pub fn create<P: PathLike>(path: P) -> io::Result<File> {
+        OpenOptions::new().write(true).create(true).truncate(true).open(path)
     }
 
     /// Creates a new file in read-write mode; error if the file exists.
@@ -417,8 +417,8 @@ impl File {
     /// }
     /// ```
     #[unstable(feature = "file_create_new", issue = "105135")]
-    pub fn create_new<P: AsRef<Path>>(path: P) -> io::Result<File> {
-        OpenOptions::new().read(true).write(true).create_new(true).open(path.as_ref())
+    pub fn create_new<P: PathLike>(path: P) -> io::Result<File> {
+        OpenOptions::new().read(true).write(true).create_new(true).open(path)
     }
 
     /// Returns a new OpenOptions object.
@@ -1073,12 +1073,12 @@ impl OpenOptions {
     /// [`NotFound`]: io::ErrorKind::NotFound
     /// [`PermissionDenied`]: io::ErrorKind::PermissionDenied
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn open<P: AsRef<Path>>(&self, path: P) -> io::Result<File> {
-        self._open(path.as_ref())
+    pub fn open<P: PathLike>(&self, path: P) -> io::Result<File> {
+        path.with_native_path(|path| self._open(path))
     }
 
-    fn _open(&self, path: &Path) -> io::Result<File> {
-        fs_imp::File::open(path, &self.0).map(|inner| File { inner })
+    fn _open(&self, path: &NativePath) -> io::Result<File> {
+        fs_imp::File::open_native(path, &self.0).map(|inner| File { inner })
     }
 }
 
@@ -1805,8 +1805,8 @@ impl AsInner<fs_imp::DirEntry> for DirEntry {
 /// }
 /// ```
 #[stable(feature = "rust1", since = "1.0.0")]
-pub fn remove_file<P: AsRef<Path>>(path: P) -> io::Result<()> {
-    fs_imp::unlink(path.as_ref())
+pub fn remove_file<P: PathLike>(path: P) -> io::Result<()> {
+    path.with_path(fs_imp::unlink)
 }
 
 /// Given a path, query the file system to get information about a file,
@@ -1843,8 +1843,8 @@ pub fn remove_file<P: AsRef<Path>>(path: P) -> io::Result<()> {
 /// }
 /// ```
 #[stable(feature = "rust1", since = "1.0.0")]
-pub fn metadata<P: AsRef<Path>>(path: P) -> io::Result<Metadata> {
-    fs_imp::stat(path.as_ref()).map(Metadata)
+pub fn metadata<P: PathLike>(path: P) -> io::Result<Metadata> {
+    path.with_path(fs_imp::stat).map(Metadata)
 }
 
 /// Query the metadata about a file without following symlinks.
@@ -1877,8 +1877,8 @@ pub fn metadata<P: AsRef<Path>>(path: P) -> io::Result<Metadata> {
 /// }
 /// ```
 #[stable(feature = "symlink_metadata", since = "1.1.0")]
-pub fn symlink_metadata<P: AsRef<Path>>(path: P) -> io::Result<Metadata> {
-    fs_imp::lstat(path.as_ref()).map(Metadata)
+pub fn symlink_metadata<P: PathLike>(path: P) -> io::Result<Metadata> {
+    path.with_path(fs_imp::lstat).map(Metadata)
 }
 
 /// Rename a file or directory to a new name, replacing the original file if
@@ -1920,8 +1920,8 @@ pub fn symlink_metadata<P: AsRef<Path>>(path: P) -> io::Result<Metadata> {
 /// }
 /// ```
 #[stable(feature = "rust1", since = "1.0.0")]
-pub fn rename<P: AsRef<Path>, Q: AsRef<Path>>(from: P, to: Q) -> io::Result<()> {
-    fs_imp::rename(from.as_ref(), to.as_ref())
+pub fn rename<P: PathLike, Q: PathLike>(from: P, to: Q) -> io::Result<()> {
+    from.with_path(|from| to.with_path(|to| fs_imp::rename(from, to)))
 }
 
 /// Copies the contents of one file to another. This function will also
@@ -1978,8 +1978,8 @@ pub fn rename<P: AsRef<Path>, Q: AsRef<Path>>(from: P, to: Q) -> io::Result<()>
 /// }
 /// ```
 #[stable(feature = "rust1", since = "1.0.0")]
-pub fn copy<P: AsRef<Path>, Q: AsRef<Path>>(from: P, to: Q) -> io::Result<u64> {
-    fs_imp::copy(from.as_ref(), to.as_ref())
+pub fn copy<P: PathLike, Q: PathLike>(from: P, to: Q) -> io::Result<u64> {
+    from.with_path(|from| to.with_path(|to| fs_imp::copy(from, to)))
 }
 
 /// Creates a new hard link on the filesystem.
@@ -2022,8 +2022,8 @@ pub fn copy<P: AsRef<Path>, Q: AsRef<Path>>(from: P, to: Q) -> io::Result<u64> {
 /// }
 /// ```
 #[stable(feature = "rust1", since = "1.0.0")]
-pub fn hard_link<P: AsRef<Path>, Q: AsRef<Path>>(original: P, link: Q) -> io::Result<()> {
-    fs_imp::link(original.as_ref(), link.as_ref())
+pub fn hard_link<P: PathLike, Q: PathLike>(original: P, link: Q) -> io::Result<()> {
+    original.with_path(|original| link.with_path(|link| fs_imp::link(original, link)))
 }
 
 /// Creates a new symbolic link on the filesystem.
@@ -2054,8 +2054,8 @@ pub fn hard_link<P: AsRef<Path>, Q: AsRef<Path>>(original: P, link: Q) -> io::Re
     note = "replaced with std::os::unix::fs::symlink and \
             std::os::windows::fs::{symlink_file, symlink_dir}"
 )]
-pub fn soft_link<P: AsRef<Path>, Q: AsRef<Path>>(original: P, link: Q) -> io::Result<()> {
-    fs_imp::symlink(original.as_ref(), link.as_ref())
+pub fn soft_link<P: PathLike, Q: PathLike>(original: P, link: Q) -> io::Result<()> {
+    original.with_path(|original| link.with_path(|link| fs_imp::symlink(original, link)))
 }
 
 /// Reads a symbolic link, returning the file that the link points to.
@@ -2088,8 +2088,8 @@ pub fn soft_link<P: AsRef<Path>, Q: AsRef<Path>>(original: P, link: Q) -> io::Re
 /// }
 /// ```
 #[stable(feature = "rust1", since = "1.0.0")]
-pub fn read_link<P: AsRef<Path>>(path: P) -> io::Result<PathBuf> {
-    fs_imp::readlink(path.as_ref())
+pub fn read_link<P: PathLike>(path: P) -> io::Result<PathBuf> {
+    path.with_path(fs_imp::readlink)
 }
 
 /// Returns the canonical, absolute form of a path with all intermediate
@@ -2131,8 +2131,8 @@ pub fn read_link<P: AsRef<Path>>(path: P) -> io::Result<PathBuf> {
 #[doc(alias = "realpath")]
 #[doc(alias = "GetFinalPathNameByHandle")]
 #[stable(feature = "fs_canonicalize", since = "1.5.0")]
-pub fn canonicalize<P: AsRef<Path>>(path: P) -> io::Result<PathBuf> {
-    fs_imp::canonicalize(path.as_ref())
+pub fn canonicalize<P: PathLike>(path: P) -> io::Result<PathBuf> {
+    path.with_path(fs_imp::canonicalize)
 }
 
 /// Creates a new, empty directory at the provided path
@@ -2172,8 +2172,8 @@ pub fn canonicalize<P: AsRef<Path>>(path: P) -> io::Result<PathBuf> {
 /// ```
 #[doc(alias = "mkdir")]
 #[stable(feature = "rust1", since = "1.0.0")]
-pub fn create_dir<P: AsRef<Path>>(path: P) -> io::Result<()> {
-    DirBuilder::new().create(path.as_ref())
+pub fn create_dir<P: PathLike>(path: P) -> io::Result<()> {
+    DirBuilder::new().create(path)
 }
 
 /// Recursively create a directory and all of its parent components if they
@@ -2216,8 +2216,8 @@ pub fn create_dir<P: AsRef<Path>>(path: P) -> io::Result<()> {
 /// }
 /// ```
 #[stable(feature = "rust1", since = "1.0.0")]
-pub fn create_dir_all<P: AsRef<Path>>(path: P) -> io::Result<()> {
-    DirBuilder::new().recursive(true).create(path.as_ref())
+pub fn create_dir_all<P: PathLike>(path: P) -> io::Result<()> {
+    DirBuilder::new().recursive(true).create(path)
 }
 
 /// Removes an empty directory.
@@ -2252,8 +2252,8 @@ pub fn create_dir_all<P: AsRef<Path>>(path: P) -> io::Result<()> {
 /// ```
 #[doc(alias = "rmdir")]
 #[stable(feature = "rust1", since = "1.0.0")]
-pub fn remove_dir<P: AsRef<Path>>(path: P) -> io::Result<()> {
-    fs_imp::rmdir(path.as_ref())
+pub fn remove_dir<P: PathLike>(path: P) -> io::Result<()> {
+    path.with_path(fs_imp::rmdir)
 }
 
 /// Removes a directory at this path, after removing all its contents. Use
@@ -2294,8 +2294,8 @@ pub fn remove_dir<P: AsRef<Path>>(path: P) -> io::Result<()> {
 /// }
 /// ```
 #[stable(feature = "rust1", since = "1.0.0")]
-pub fn remove_dir_all<P: AsRef<Path>>(path: P) -> io::Result<()> {
-    fs_imp::remove_dir_all(path.as_ref())
+pub fn remove_dir_all<P: PathLike>(path: P) -> io::Result<()> {
+    path.with_path(fs_imp::remove_dir_all)
 }
 
 /// Returns an iterator over the entries within a directory.
@@ -2369,8 +2369,8 @@ pub fn remove_dir_all<P: AsRef<Path>>(path: P) -> io::Result<()> {
 /// }
 /// ```
 #[stable(feature = "rust1", since = "1.0.0")]
-pub fn read_dir<P: AsRef<Path>>(path: P) -> io::Result<ReadDir> {
-    fs_imp::readdir(path.as_ref()).map(ReadDir)
+pub fn read_dir<P: PathLike>(path: P) -> io::Result<ReadDir> {
+    path.with_path(fs_imp::readdir).map(ReadDir)
 }
 
 /// Changes the permissions found on a file or a directory.
@@ -2404,8 +2404,8 @@ pub fn read_dir<P: AsRef<Path>>(path: P) -> io::Result<ReadDir> {
 /// }
 /// ```
 #[stable(feature = "set_permissions", since = "1.1.0")]
-pub fn set_permissions<P: AsRef<Path>>(path: P, perm: Permissions) -> io::Result<()> {
-    fs_imp::set_perm(path.as_ref(), perm.0)
+pub fn set_permissions<P: PathLike>(path: P, perm: Permissions) -> io::Result<()> {
+    path.with_path(|path| fs_imp::set_perm(path, perm.0))
 }
 
 impl DirBuilder {
@@ -2464,8 +2464,8 @@ impl DirBuilder {
     /// assert!(fs::metadata(path).unwrap().is_dir());
     /// ```
     #[stable(feature = "dir_builder", since = "1.6.0")]
-    pub fn create<P: AsRef<Path>>(&self, path: P) -> io::Result<()> {
-        self._create(path.as_ref())
+    pub fn create<P: PathLike>(&self, path: P) -> io::Result<()> {
+        path.with_path(|path| self._create(path))
     }
 
     fn _create(&self, path: &Path) -> io::Result<()> {
@@ -2534,6 +2534,6 @@ impl AsInnerMut<fs_imp::DirBuilder> for DirBuilder {
 // instead.
 #[unstable(feature = "fs_try_exists", issue = "83186")]
 #[inline]
-pub fn try_exists<P: AsRef<Path>>(path: P) -> io::Result<bool> {
-    fs_imp::try_exists(path.as_ref())
+pub fn try_exists<P: PathLike>(path: P) -> io::Result<bool> {
+    path.with_path(fs_imp::try_exists)
 }

library/std/src/os/unix/ffi/mod.rs

@@ -38,5 +38,24 @@
 
 mod os_str;
 
+use crate::ffi::CStr;
+use crate::path::NativePath;
+
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use self::os_str::{OsStrExt, OsStringExt};
+
+#[unstable(feature = "pathlike", issue = "none")]
+pub trait NativePathExt: crate::sealed::Sealed {
+    fn from_cstr(cstr: &CStr) -> &NativePath;
+    fn into_cstr(&self) -> &CStr;
+}
+
+#[unstable(feature = "pathlike", issue = "none")]
+impl NativePathExt for NativePath {
+    fn from_cstr(cstr: &CStr) -> &NativePath {
+        unsafe { &*(cstr as *const CStr as *const NativePath) }
+    }
+    fn into_cstr(&self) -> &CStr {
+        unsafe { &*(self as *const Self as *const CStr) }
+    }
+}

library/std/src/os/windows/ffi.rs

@@ -54,6 +54,7 @@
 #![stable(feature = "rust1", since = "1.0.0")]
 
 use crate::ffi::{OsStr, OsString};
+use crate::path::NativePath;
 use crate::sealed::Sealed;
 use crate::sys::os_str::Buf;
 use crate::sys_common::wtf8::Wtf8Buf;
@@ -134,3 +135,19 @@ impl OsStrExt for OsStr {
         self.as_inner().inner.encode_wide()
     }
 }
+
+#[unstable(feature = "pathlike", issue = "none")]
+pub trait NativePathExt: Sealed {
+    fn from_wide(wide: &[u16]) -> &NativePath;
+    fn into_wide(&self) -> &[u16];
+}
+#[unstable(feature = "pathlike", issue = "none")]
+impl NativePathExt for NativePath {
+    fn from_wide(wide: &[u16]) -> &NativePath {
+        assert_eq!(wide.last(), Some(&0));
+        unsafe { &*(wide as *const [u16] as *const Self) }
+    }
+    fn into_wide(&self) -> &[u16] {
+        unsafe { &*(self as *const Self as *const [u16]) }
+    }
+}