Add features corresponding to Rust 1.58's new filesystem features. (#218)

* Add features corresponding to Rust 1.58's new filesystem features.

Add `Metadata::is_symlink` and `File::options`, corresponding to the new
std features in [Rust 1.58].

This also updates tests/fs.rs and tests/fs_utf8.rs to the latest changes
from upstream Rust.

[Rust 1.58]: https://blog.rust-lang.org/2022/01/13/Rust-1.58.0.html

* Use `io::ErrorKind::Unsupported` on nightly.

On Rust nightly, use `io::ErrorKind::Unsupported` for unsupported OS
features.

Author: sunfishcode

Cargo.toml

@@ -24,6 +24,7 @@ cap-tempfile = { path = "cap-tempfile", version = "^0.22.2-alpha.0"}
 rand = "0.8.1"
 tempfile = "3.1.0"
 camino = "1.0.5"
+libc = "0.2.100"
 
 [target.'cfg(not(windows))'.dev-dependencies]
 rustix = "0.31.0"

build.rs

@@ -6,6 +6,7 @@ fn main() {
     use_feature_or_nothing("clamp"); // https://github.com/rust-lang/rust/issues/44095
     use_feature_or_nothing("extend_one"); // https://github.com/rust-lang/rust/issues/72631
     use_feature_or_nothing("io_error_more"); // https://github.com/rust-lang/rust/issues/86442
+    use_feature_or_nothing("io_error_uncategorized");
     use_feature_or_nothing("pattern"); // https://github.com/rust-lang/rust/issues/27721
     use_feature_or_nothing("seek_convenience"); // https://github.com/rust-lang/rust/issues/59359
     use_feature_or_nothing("shrink_to"); // https://github.com/rust-lang/rust/issues/56431

cap-async-std/src/fs/file.rs

@@ -149,6 +149,15 @@ impl File {
             .await
             .map(|f| Self::from_std(f.into()))
     }
+
+    /// Returns a new `OpenOptions` object.
+    ///
+    /// This corresponds to [`async_std::fs::File::options`].
+    #[must_use]
+    #[inline]
+    pub fn options() -> OpenOptions {
+        OpenOptions::new()
+    }
 }
 
 #[cfg(not(target_os = "wasi"))]

cap-async-std/src/fs_utf8/file.rs

@@ -142,6 +142,15 @@ impl File {
             .await
             .map(Self::from_cap_std)
     }
+
+    /// Returns a new `OpenOptions` object.
+    ///
+    /// This corresponds to [`async_std::fs::File::options`].
+    #[must_use]
+    #[inline]
+    pub fn options() -> OpenOptions {
+        OpenOptions::new()
+    }
 }
 
 #[cfg(not(windows))]

cap-primitives/build.rs

@@ -6,6 +6,7 @@ fn main() {
                                                  // https://doc.rust-lang.org/unstable-book/library-features/windows-file-type-ext.html
     use_feature_or_nothing("windows_file_type_ext");
     use_feature_or_nothing("io_error_more"); // https://github.com/rust-lang/rust/issues/86442
+    use_feature_or_nothing("io_error_uncategorized");
 
     // Don't rerun this on changes other than build.rs, as we only depend on
     // the rustc version.

cap-primitives/src/fs/metadata.rs

@@ -105,6 +105,14 @@ impl Metadata {
         self.file_type.is_file()
     }
 
+    /// Returns `true` if this metadata is for a symbolic link.
+    ///
+    /// This corresponds to [`std::fs::Metadata::is_symlink`].
+    #[inline]
+    pub fn is_symlink(&self) -> bool {
+        self.file_type.is_symlink()
+    }
+
     /// Returns the size of the file, in bytes, this metadata is for.
     ///
     /// This corresponds to [`std::fs::Metadata::len`].
@@ -126,38 +134,74 @@ impl Metadata {
     /// This corresponds to [`std::fs::Metadata::modified`].
     #[inline]
     pub fn modified(&self) -> io::Result<SystemTime> {
-        self.modified.ok_or_else(|| {
-            io::Error::new(
-                io::ErrorKind::Other,
-                "modified time metadata not available on this platform",
-            )
-        })
+        #[cfg(io_error_uncategorized)]
+        {
+            self.modified.ok_or_else(|| {
+                io::Error::new(
+                    io::ErrorKind::Unsupported,
+                    "modified time metadata not available on this platform",
+                )
+            })
+        }
+        #[cfg(not(io_error_uncategorized))]
+        {
+            self.modified.ok_or_else(|| {
+                io::Error::new(
+                    io::ErrorKind::Other,
+                    "modified time metadata not available on this platform",
+                )
+            })
+        }
     }
 
     /// Returns the last access time of this metadata.
     ///
     /// This corresponds to [`std::fs::Metadata::accessed`].
     #[inline]
     pub fn accessed(&self) -> io::Result<SystemTime> {
-        self.accessed.ok_or_else(|| {
-            io::Error::new(
-                io::ErrorKind::Other,
-                "accessed time metadata not available on this platform",
-            )
-        })
+        #[cfg(io_error_uncategorized)]
+        {
+            self.accessed.ok_or_else(|| {
+                io::Error::new(
+                    io::ErrorKind::Unsupported,
+                    "accessed time metadata not available on this platform",
+                )
+            })
+        }
+        #[cfg(not(io_error_uncategorized))]
+        {
+            self.accessed.ok_or_else(|| {
+                io::Error::new(
+                    io::ErrorKind::Other,
+                    "accessed time metadata not available on this platform",
+                )
+            })
+        }
     }
 
     /// Returns the creation time listed in this metadata.
     ///
     /// This corresponds to [`std::fs::Metadata::created`].
     #[inline]
     pub fn created(&self) -> io::Result<SystemTime> {
-        self.created.ok_or_else(|| {
-            io::Error::new(
-                io::ErrorKind::Other,
-                "created time metadata not available on this platform",
-            )
-        })
+        #[cfg(io_error_uncategorized)]
+        {
+            self.created.ok_or_else(|| {
+                io::Error::new(
+                    io::ErrorKind::Unsupported,
+                    "created time metadata not available on this platform",
+                )
+            })
+        }
+        #[cfg(not(io_error_uncategorized))]
+        {
+            self.created.ok_or_else(|| {
+                io::Error::new(
+                    io::ErrorKind::Other,
+                    "created time metadata not available on this platform",
+                )
+            })
+        }
     }
 
     /// Determine if `self` and `other` refer to the same inode on the same

cap-primitives/src/lib.rs

@@ -13,6 +13,7 @@
 )]
 #![cfg_attr(io_lifetimes_use_std, feature(io_safety))]
 #![cfg_attr(io_error_more, feature(io_error_more))]
+#![cfg_attr(io_error_uncategorized, feature(io_error_uncategorized))]
 
 #[cfg(not(windows))]
 mod rustix;

cap-std/src/fs/file.rs

@@ -146,6 +146,15 @@ impl File {
         let std = open_ambient(path.as_ref(), options, ambient_authority)?;
         Ok(Self::from_std(std))
     }
+
+    /// Returns a new `OpenOptions` object.
+    ///
+    /// This corresponds to [`std::fs::File::options`].
+    #[must_use]
+    #[inline]
+    pub fn options() -> OpenOptions {
+        OpenOptions::new()
+    }
 }
 
 #[inline]

cap-std/src/fs_utf8/file.rs

@@ -155,6 +155,15 @@ impl File {
             ambient_authority,
         )?))
     }
+
+    /// Returns a new `OpenOptions` object.
+    ///
+    /// This corresponds to [`std::fs::File::options`].
+    #[must_use]
+    #[inline]
+    pub fn options() -> OpenOptions {
+        OpenOptions::new()
+    }
 }
 
 #[cfg(not(windows))]

tests/fs.rs

@@ -1,15 +1,21 @@
-// This file is derived from Rust's library/std/src/fs.rs at revision
-// 108e90ca78f052c0c1c49c42a22c85620be19712.
-//
-// This is the contents of the `tests` module, ported to use `cap_std`.
+// This file is derived from Rust's library/std/src/fs/tests.rs at revision
+// e4b1d5841494d6eb7f4944c91a057e16b0f0a9ea.
+
+#![cfg_attr(io_error_uncategorized, feature(io_error_uncategorized))]
 
 #[macro_use]
 mod sys_common;
+#[macro_use]
+mod sys;
 
 use std::io::prelude::*;
 
+#[cfg(target_os = "macos")]
+use crate::sys::weak::weak;
 use cap_std::ambient_authority;
 use cap_std::fs::{self, Dir, OpenOptions};
+#[cfg(target_os = "macos")]
+use libc::{c_char, c_int};
 use std::io::{self, ErrorKind, SeekFrom};
 use std::path::{Path, PathBuf};
 use std::str;
@@ -59,13 +65,23 @@ pub fn got_symlink_permission(tmpdir: &TempDir) -> bool {
     let link = "some_hopefully_unique_link_name";
 
     match symlink_file(r"nonexisting_target", tmpdir, link) {
-        Ok(_) => true,
         // ERROR_PRIVILEGE_NOT_HELD = 1314
         Err(ref err) if err.raw_os_error() == Some(1314) => false,
-        Err(_) => true,
+        Ok(_) | Err(_) => true,
     }
 }
 
+#[cfg(target_os = "macos")]
+fn able_to_not_follow_symlinks_while_hard_linking() -> bool {
+    weak!(fn linkat(c_int, *const c_char, c_int, *const c_char, c_int) -> c_int);
+    linkat.get().is_some()
+}
+
+#[cfg(not(target_os = "macos"))]
+fn able_to_not_follow_symlinks_while_hard_linking() -> bool {
+    return true;
+}
+
 #[test]
 fn file_test_io_smoke_test() {
     let message = "it's alright. have a good time";
@@ -838,7 +854,7 @@ fn symlink_noexist() {
     };
 
     // Use a relative path for testing. Symlinks get normalized by Windows,
-    // so we may not get the same path back for absolute paths
+    // so we might not get the same path back for absolute paths
     check!(symlink_file(&"foo", &tmpdir, "bar"));
     assert_eq!(check!(tmpdir.read_link("bar")).to_str().unwrap(), "foo");
 }
@@ -1386,8 +1402,15 @@ fn metadata_access_times() {
         // Not always available
         match (a.created(), b.created()) {
             (Ok(t1), Ok(t2)) => assert!(t1 <= t2),
+            #[cfg(not(io_error_uncategorized))]
             (Err(e1), Err(e2))
                 if e1.kind() == ErrorKind::Other && e2.kind() == ErrorKind::Other => {}
+            #[cfg(io_error_uncategorized)]
+            (Err(e1), Err(e2))
+                if e1.kind() == ErrorKind::Uncategorized
+                    && e2.kind() == ErrorKind::Uncategorized
+                    || e1.kind() == ErrorKind::Unsupported
+                        && e2.kind() == ErrorKind::Unsupported => {}
             (a, b) => panic!(
                 "creation time must be always supported or not supported: {:?} {:?}",
                 a, b,
@@ -1403,6 +1426,9 @@ fn symlink_hard_link() {
     if !got_symlink_permission(&tmpdir) {
         return;
     }
+    if !able_to_not_follow_symlinks_while_hard_linking() {
+        return;
+    }
 
     // Create "file", a file.
     check!(tmpdir.create("file"));
@@ -1453,3 +1479,41 @@ fn symlink_hard_link() {
         .file_type()
         .is_symlink());
 }
+
+/// Ensure `fs::create_dir` works on Windows with longer paths.
+#[test]
+#[cfg(windows)]
+fn create_dir_long_paths() {
+    use std::ffi::OsStr;
+    use std::iter;
+    use std::os::windows::ffi::OsStrExt;
+    const PATH_LEN: usize = 247;
+
+    let tmpdir = tmpdir();
+    let mut path = PathBuf::new();
+    path.push("a");
+    let mut path = path.into_os_string();
+
+    let utf16_len = path.encode_wide().count();
+    if utf16_len >= PATH_LEN {
+        // Skip the test in the unlikely event the local user has a long temp directory
+        // path. This should not affect CI.
+        return;
+    }
+    // Increase the length of the path.
+    path.extend(iter::repeat(OsStr::new("a")).take(PATH_LEN - utf16_len));
+
+    // This should succeed.
+    tmpdir.create_dir(&path).unwrap();
+
+    // This will fail if the path isn't converted to verbatim.
+    path.push("a");
+    tmpdir.create_dir(&path).unwrap();
+
+    // #90940: Ensure an empty path returns the "Not Found" error.
+    let path = Path::new("");
+    assert_eq!(
+        tmpdir.canonicalize(path).unwrap_err().kind(),
+        std::io::ErrorKind::NotFound
+    );
+}