Windows implementation of NativePath

Author: ChrisDenton

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

@@ -54,6 +54,8 @@
 #![stable(feature = "rust1", since = "1.0.0")]
 
 use crate::ffi::{OsStr, OsString};
+#[cfg(not(target_os = "uefi"))]
+use crate::path::NativePath;
 use crate::sealed::Sealed;
 use crate::sys::os_str::Buf;
 use crate::sys_common::wtf8::Wtf8Buf;
@@ -134,3 +136,37 @@ impl OsStrExt for OsStr {
         self.as_inner().inner.encode_wide()
     }
 }
+
+/// On Windows `NativePath` wraps a wide string for use in filesystem function calls.
+/// These strings are `&[u16]` slices.
+///
+/// # Wide strings
+///
+/// Filesystem paths in Windows are encoded as UTF-16 strings.
+/// However, because the kernel does not verify validity this may contain invalid UTF-16.
+/// Therefore we use the term "wide string" for potentially invalid UTF-16.
+#[cfg(windows)]
+#[unstable(feature = "fs_native_path", issue = "108979")]
+pub trait NativePathExt: Sealed {
+    /// Wrap a Windows wide string as a `NativePath`.
+    /// The `wide` string must be null terminated and must not otherwise contain nulls.
+    fn from_wide(wide: &[u16]) -> &NativePath;
+    /// Wrap a Windows wide string as a `NativePath` without checking for null termination or internal nulls.
+    unsafe fn from_wide_unchecked(wide: &[u16]) -> &NativePath;
+    /// Unwrap the `NativePath` to return the inner wide string.
+    fn into_wide(&self) -> &[u16];
+}
+#[cfg(windows)]
+#[unstable(feature = "fs_native_path", issue = "108979")]
+impl NativePathExt for NativePath {
+    fn from_wide(wide: &[u16]) -> &NativePath {
+        assert_eq!(crate::sys::unrolled_find_u16s(0, wide), Some(wide.len().saturating_sub(1)));
+        unsafe { Self::from_wide_unchecked(wide) }
+    }
+    unsafe fn from_wide_unchecked(wide: &[u16]) -> &NativePath {
+        &*(wide as *const [u16] as *const Self)
+    }
+    fn into_wide(&self) -> &[u16] {
+        unsafe { &*(self as *const Self as *const [u16]) }
+    }
+}

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

@@ -6,7 +6,7 @@
 
 use crate::fs::{self, Metadata, OpenOptions};
 use crate::io;
-use crate::path::Path;
+use crate::path::AsPath;
 use crate::sealed::Sealed;
 use crate::sys;
 use crate::sys_common::{AsInner, AsInnerMut, IntoInner};
@@ -578,8 +578,9 @@ impl FileTimesExt for fs::FileTimes {
 ///
 /// [symlink-security]: https://docs.microsoft.com/en-us/windows/security/threat-protection/security-policy-settings/create-symbolic-links
 #[stable(feature = "symlink", since = "1.1.0")]
-pub fn symlink_file<P: AsRef<Path>, Q: AsRef<Path>>(original: P, link: Q) -> io::Result<()> {
-    sys::fs::symlink_inner(original.as_ref(), link.as_ref(), false)
+pub fn symlink_file<P: AsPath, Q: AsPath>(original: P, link: Q) -> io::Result<()> {
+    original
+        .with_path(|original| link.with_path(|link| sys::fs::symlink_inner(original, link, false)))
 }
 
 /// Creates a new symlink to a directory on the filesystem.
@@ -617,6 +618,7 @@ pub fn symlink_file<P: AsRef<Path>, Q: AsRef<Path>>(original: P, link: Q) -> io:
 ///
 /// [symlink-security]: https://docs.microsoft.com/en-us/windows/security/threat-protection/security-policy-settings/create-symbolic-links
 #[stable(feature = "symlink", since = "1.1.0")]
-pub fn symlink_dir<P: AsRef<Path>, Q: AsRef<Path>>(original: P, link: Q) -> io::Result<()> {
-    sys::fs::symlink_inner(original.as_ref(), link.as_ref(), true)
+pub fn symlink_dir<P: AsPath, Q: AsPath>(original: P, link: Q) -> io::Result<()> {
+    original
+        .with_path(|original| link.with_path(|link| sys::fs::symlink_inner(original, link, true)))
 }

library/std/src/sys/pal/windows/fs.rs

@@ -11,6 +11,7 @@ use crate::ptr;
 use crate::slice;
 use crate::sync::Arc;
 use crate::sys::handle::Handle;
+use crate::sys::path::NativePath;
 use crate::sys::time::SystemTime;
 use crate::sys::{c, cvt, Align8};
 use crate::sys_common::{AsInner, FromInner, IntoInner};
@@ -19,6 +20,60 @@ use crate::thread;
 use super::{api, to_u16s, IoResult};
 use crate::sys::path::maybe_verbatim;
 
+/// The crate-public interface
+pub(crate) mod fs_imp {
+    use crate::io;
+    use crate::path::AsPath;
+    use crate::path::PathBuf;
+    use crate::sys::fs;
+    pub(crate) use crate::sys::fs::{
+        DirBuilder, DirEntry, File, FileAttr, FilePermissions, FileTimes, FileType, OpenOptions,
+        ReadDir,
+    };
+    pub(crate) fn remove_file<P: AsPath>(path: P) -> io::Result<()> {
+        path.with_path(fs::unlink)
+    }
+    pub(crate) fn symlink_metadata<P: AsPath>(path: P) -> io::Result<FileAttr> {
+        path.with_path(fs::lstat)
+    }
+    pub(crate) fn metadata<P: AsPath>(path: P) -> io::Result<FileAttr> {
+        path.with_path(fs::stat)
+    }
+    pub(crate) fn rename<P: AsPath, Q: AsPath>(from: P, to: Q) -> io::Result<()> {
+        from.with_path(|from| to.with_path(|to| fs::rename(from, to)))
+    }
+    pub(crate) fn hard_link<P: AsPath, Q: AsPath>(original: P, link: Q) -> io::Result<()> {
+        original.with_path(|original| link.with_path(|link| fs::link(original, link)))
+    }
+    pub(crate) fn soft_link<P: AsPath, Q: AsPath>(original: P, link: Q) -> io::Result<()> {
+        original.with_path(|original| link.with_path(|link| fs::symlink(original, link)))
+    }
+    pub(crate) fn remove_dir<P: AsPath>(path: P) -> io::Result<()> {
+        path.with_path(fs::rmdir)
+    }
+    pub(crate) fn read_dir<P: AsPath>(path: P) -> io::Result<ReadDir> {
+        path.with_path(fs::readdir)
+    }
+    pub(crate) fn set_permissions<P: AsPath>(path: P, perms: FilePermissions) -> io::Result<()> {
+        path.with_path(|path| fs::set_perm(path, perms))
+    }
+    pub(crate) fn copy<P: AsPath, Q: AsPath>(from: P, to: Q) -> io::Result<u64> {
+        from.with_path(|from| to.with_path(|to| fs::copy(from, to)))
+    }
+    pub(crate) fn canonicalize<P: AsPath>(path: P) -> io::Result<PathBuf> {
+        path.with_path(fs::canonicalize)
+    }
+    pub(crate) fn remove_dir_all<P: AsPath>(path: P) -> io::Result<()> {
+        path.with_path(fs::remove_dir_all)
+    }
+    pub(crate) fn read_link<P: AsPath>(path: P) -> io::Result<PathBuf> {
+        path.with_path(fs::readlink)
+    }
+    pub(crate) fn try_exists<P: AsPath>(path: P) -> io::Result<bool> {
+        path.with_path(fs::try_exists)
+    }
+}
+
 pub struct File {
     handle: Handle,
 }
@@ -294,8 +349,12 @@ impl OpenOptions {
 }
 
 impl File {
-    pub fn open(path: &Path, opts: &OpenOptions) -> io::Result<File> {
+    pub(super) fn open(path: &Path, opts: &OpenOptions) -> io::Result<File> {
         let path = maybe_verbatim(path)?;
+        let path = unsafe { NativePath::new_unchecked(&path) };
+        Self::open_native(path, opts)
+    }
+    pub fn open_native(path: &NativePath, opts: &OpenOptions) -> io::Result<File> {
         let creation = opts.get_creation_mode()?;
         let handle = unsafe {
             c::CreateFileW(

library/std/src/sys/path/windows.rs

@@ -1,6 +1,6 @@
 use crate::ffi::{OsStr, OsString};
 use crate::io;
-use crate::path::{Path, PathBuf, Prefix};
+use crate::path::{AsPath, Path, PathBuf, Prefix};
 use crate::ptr;
 use crate::sys::pal::{c, fill_utf16_buf, os2path, to_u16s};
 
@@ -10,6 +10,42 @@ mod tests;
 pub const MAIN_SEP_STR: &str = "\\";
 pub const MAIN_SEP: char = '\\';
 
+/// A null-terminated `[u16]` string.
+#[unstable(feature = "fs_native_path_internals", issue = "none")]
+#[repr(transparent)]
+#[derive(Debug)]
+pub struct NativePath(pub [u16]);
+impl NativePath {
+    pub(crate) unsafe fn new_unchecked(native: &[u16]) -> &Self {
+        unsafe { &*(native as *const [u16] as *const Self) }
+    }
+    pub(crate) fn as_ptr(&self) -> *const u16 {
+        self.0.as_ptr()
+    }
+}
+
+#[unstable(feature = "fs_native_path_internals", issue = "none")]
+impl<P: AsRef<Path>> AsPath for P {
+    fn with_path<T, F: FnOnce(&Path) -> io::Result<T>>(self, f: F) -> io::Result<T> {
+        f(self.as_ref())
+    }
+    fn with_native_path<T, F: Fn(&NativePath) -> io::Result<T>>(self, f: F) -> io::Result<T> {
+        let path = maybe_verbatim(self.as_ref())?;
+        f(unsafe { NativePath::new_unchecked(&path) })
+    }
+}
+
+#[unstable(feature = "fs_native_path_internals", issue = "none")]
+impl AsPath for &crate::path::NativePath {
+    fn with_path<T, F: FnOnce(&Path) -> io::Result<T>>(self, f: F) -> io::Result<T> {
+        let path = os2path(&self.0.0[..self.0.0.len().saturating_sub(1)]);
+        f(&path)
+    }
+    fn with_native_path<T, F: Fn(&NativePath) -> io::Result<T>>(self, f: F) -> io::Result<T> {
+        f(&self.0)
+    }
+}
+
 #[inline]
 pub fn is_sep_byte(b: u8) -> bool {
     b == b'/' || b == b'\\'