Switch to custom FileTypeExt traits.

std has recently sealed its `FileTypeExt` traits, so cap-primitives can
no longer implement them for its own types. Fortunately, these traits
are just used as extension traits, so we can just define our own copies
of them, and implement those instead.

Fixes #270.

Author: sunfishcode

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

@@ -37,6 +37,10 @@ pub use read_dir::ReadDir;
 #[cfg(not(target_os = "wasi"))]
 pub use cap_primitives::fs::{DirBuilder, FileType, Metadata, OpenOptions, Permissions};
 
+// Re-export conditional types from `cap_primitives`.
+#[cfg(any(unix, target_os = "vxworks", all(windows, windows_file_type_ext)))]
+pub use cap_primitives::fs::FileTypeExt;
+
 // Re-export things from `async_std` that we can use as-is.
 #[cfg(target_os = "wasi")]
 pub use async_std::fs::{DirBuilder, FileType, Metadata, OpenOptions, Permissions};

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

@@ -22,6 +22,10 @@ pub use read_dir::ReadDir;
 // Re-export things from `cap_std::fs` that we can use as-is.
 pub use crate::fs::{DirBuilder, FileType, Metadata, OpenOptions, Permissions};
 
+// Re-export conditional types from `cap_primitives`.
+#[cfg(any(unix, target_os = "vxworks", all(windows, windows_file_type_ext)))]
+pub use cap_primitives::fs::FileTypeExt;
+
 // Re-export `camino` to make it easy for users to depend on the same
 // version we do, because we use its types in our public API.
 pub use camino;

cap-fs-ext/src/file_type_ext.rs

@@ -67,22 +67,22 @@ impl FileTypeExt for std::fs::FileType {
 impl FileTypeExt for cap_primitives::fs::FileType {
     #[inline]
     fn is_block_device(&self) -> bool {
-        std::os::unix::fs::FileTypeExt::is_block_device(self)
+        cap_primitives::fs::FileTypeExt::is_block_device(self)
     }
 
     #[inline]
     fn is_char_device(&self) -> bool {
-        std::os::unix::fs::FileTypeExt::is_char_device(self)
+        cap_primitives::fs::FileTypeExt::is_char_device(self)
     }
 
     #[inline]
     fn is_fifo(&self) -> bool {
-        std::os::unix::fs::FileTypeExt::is_fifo(self)
+        cap_primitives::fs::FileTypeExt::is_fifo(self)
     }
 
     #[inline]
     fn is_socket(&self) -> bool {
-        std::os::unix::fs::FileTypeExt::is_socket(self)
+        cap_primitives::fs::FileTypeExt::is_socket(self)
     }
 }
 

cap-primitives/src/fs/file_type.rs

@@ -84,8 +84,23 @@ impl FileType {
     }
 }
 
-#[cfg(unix)]
-impl std::os::unix::fs::FileTypeExt for FileType {
+/// Unix-specific extensions for [`FileType`].
+///
+/// This corresponds to [`std::os::unix::fs::FileTypeExt`].
+#[cfg(any(unix, target_os = "vxworks"))]
+pub trait FileTypeExt {
+    /// Returns `true` if this file type is a block device.
+    fn is_block_device(&self) -> bool;
+    /// Returns `true` if this file type is a character device.
+    fn is_char_device(&self) -> bool;
+    /// Returns `true` if this file type is a fifo.
+    fn is_fifo(&self) -> bool;
+    /// Returns `true` if this file type is a socket.
+    fn is_socket(&self) -> bool;
+}
+
+#[cfg(any(unix, target_os = "vxworks"))]
+impl FileTypeExt for FileType {
     #[inline]
     fn is_block_device(&self) -> bool {
         self.0 == Inner::Ext(ImplFileTypeExt::block_device())
@@ -107,31 +122,19 @@ impl std::os::unix::fs::FileTypeExt for FileType {
     }
 }
 
-#[cfg(target_os = "vxworks")]
-impl std::os::vxworks::fs::FileTypeExt for FileType {
-    #[inline]
-    fn is_block_device(&self) -> bool {
-        self.0 == Inner::Ext(FileTypeExt::BlockDevice)
-    }
-
-    #[inline]
-    fn is_char_device(&self) -> bool {
-        self.0 == Inner::Ext(FileTypeExt::CharDevice)
-    }
-
-    #[inline]
-    fn is_fifo(&self) -> bool {
-        self.0 == Inner::Ext(FileTypeExt::Fifo)
-    }
-
-    #[inline]
-    fn is_socket(&self) -> bool {
-        self.0 == Inner::Ext(FileTypeExt::Socket)
-    }
+/// Windows-specific extensions for [`FileType`].
+///
+/// This corresponds to [`std::os::windows::fs::FileTypeExt`].
+#[cfg(all(windows, windows_file_type_ext))]
+pub trait FileTypeExt {
+    /// Returns `true` if this file type is a symbolic link that is also a directory.
+    fn is_symlink_dir(&self) -> bool;
+    /// Returns `true` if this file type is a symbolic link that is also a file.
+    fn is_symlink_file(&self) -> bool;
 }
 
 #[cfg(all(windows, windows_file_type_ext))]
-impl std::os::windows::fs::FileTypeExt for FileType {
+impl FileTypeExt for FileType {
     #[inline]
     fn is_symlink_dir(&self) -> bool {
         self.0 == Inner::Ext(FileTypeExt::symlink_dir())

cap-primitives/src/fs/mod.rs

@@ -66,6 +66,8 @@ pub use dir_entry::DirEntry;
 pub use dir_entry::_WindowsDirEntryExt;
 pub use dir_options::DirOptions;
 pub use file_type::FileType;
+#[cfg(any(unix, target_os = "vxworks", all(windows, windows_file_type_ext)))]
+pub use file_type::FileTypeExt;
 #[cfg(windows)]
 pub use file_type::_WindowsFileTypeExt;
 pub use follow_symlinks::FollowSymlinks;

cap-std/src/fs/mod.rs

@@ -34,3 +34,7 @@ pub use read_dir::ReadDir;
 
 // Re-export types from `cap_primitives`.
 pub use cap_primitives::fs::{DirBuilder, FileType, Metadata, OpenOptions, Permissions};
+
+// Re-export conditional types from `cap_primitives`.
+#[cfg(any(unix, target_os = "vxworks", all(windows, windows_file_type_ext)))]
+pub use cap_primitives::fs::FileTypeExt;

cap-std/src/fs_utf8/mod.rs

@@ -24,6 +24,10 @@ pub use read_dir::ReadDir;
 // Re-export things from `cap_std::fs` that we can use as-is.
 pub use crate::fs::{DirBuilder, FileType, Metadata, OpenOptions, Permissions};
 
+// Re-export conditional types from `cap_primitives`.
+#[cfg(any(unix, target_os = "vxworks", all(windows, windows_file_type_ext)))]
+pub use cap_primitives::fs::FileTypeExt;
+
 // Re-export `camino` to make it easy for users to depend on the same
 // version we do, because we use its types in our public API.
 pub use camino;

tests/fs_additional.rs

@@ -913,17 +913,22 @@ fn check_metadata(std: &std::fs::Metadata, cap: &cap_std::fs::Metadata) {
     assert_eq!(std.file_type().is_symlink(), cap.file_type().is_symlink());
     #[cfg(unix)]
     {
-        use std::os::unix::fs::FileTypeExt;
         assert_eq!(
-            std.file_type().is_block_device(),
-            cap.file_type().is_block_device()
+            std::os::unix::fs::FileTypeExt::is_block_device(&std.file_type()),
+            cap_std::fs::FileTypeExt::is_block_device(&cap.file_type())
         );
         assert_eq!(
-            std.file_type().is_char_device(),
-            cap.file_type().is_char_device()
+            std::os::unix::fs::FileTypeExt::is_char_device(&std.file_type()),
+            cap_std::fs::FileTypeExt::is_char_device(&cap.file_type())
+        );
+        assert_eq!(
+            std::os::unix::fs::FileTypeExt::is_fifo(&std.file_type()),
+            cap_std::fs::FileTypeExt::is_fifo(&cap.file_type())
+        );
+        assert_eq!(
+            std::os::unix::fs::FileTypeExt::is_socket(&std.file_type()),
+            cap_std::fs::FileTypeExt::is_socket(&cap.file_type())
         );
-        assert_eq!(std.file_type().is_fifo(), cap.file_type().is_fifo());
-        assert_eq!(std.file_type().is_socket(), cap.file_type().is_socket());
     }
 
     assert_eq!(std.len(), cap.len());