A treemap for finding and removing what fills your disk, for Omarchy. Rust + GPUI.
Rust
scan: list macOS directories with getattrlistbulk, one call per buffer of entries
Joshua Gossefdc2eb330d96
diff --git a/AGENTS.md b/AGENTS.mdindex 0dec4c7..5ce375e 100644--- a/AGENTS.md+++ b/AGENTS.md@@ -62,8 +62,11 @@ and `cargo build --release` directly; CI runs the gate on both systems.## Invariants1. **Sizes come from `st_blocks * 512` unless apparent size was asked for.**- That is the number that comes back when a file is deleted. On Windows it- is the allocation the directory listing reports; see `windows.rs`. An+ That is the number that comes back when a file is deleted. On macOS the+ directory listing reports it and `st_size` for a whole buffer of entries:+ every fork's allocation, and the data fork's length; see `macos.rs`. On+ Windows it is the allocation the directory listing reports; see+ `windows.rs`. Anelevated scan of a whole NTFS drive reads it from the master file tableinstead, keeping the walk's rules for hidden entries, links, cloudfolders and depth; see `mft.rs`. That path counts every stream's@@ -106,7 +109,8 @@ and `cargo build --release` directly; CI runs the gate on both systems.| tile geometry, nesting, the merged tail | `crates/disktree-core/src/treemap.rs` || anything that deletes, or refuses to | `crates/disktree-core/src/removal.rs` || free space and projections | `crates/disktree-core/src/space.rs` |-| what Windows lists, measures and compares differently | `crates/disktree-core/src/windows.rs` — the only `unsafe` |+| what macOS lists and measures in bulk | `crates/disktree-core/src/macos.rs` — `unsafe` for `getattrlistbulk` |+| what Windows lists, measures and compares differently | `crates/disktree-core/src/windows.rs` — `unsafe` for Win32 || reading a whole NTFS drive from its file table | `crates/disktree-core/src/mft.rs` || a key, a screen transition, a mark | `crates/disktree-app/src/state.rs` || spacing, type and size | `crates/disktree-app/src/ui.rs` — tokens only, no `px` in layout |diff --git a/crates/disktree-core/src/lib.rs b/crates/disktree-core/src/lib.rsindex 9d2ee86..ef24fcf 100644--- a/crates/disktree-core/src/lib.rs+++ b/crates/disktree-core/src/lib.rs@@ -10,6 +10,8 @@ pub mod classify;pub mod export;pub mod filter;pub mod insights;+#[cfg(target_os = "macos")]+mod macos;#[cfg(windows)]mod mft;pub mod removal;diff --git a/crates/disktree-core/src/macos.rs b/crates/disktree-core/src/macos.rsnew file mode 100644index 0000000..1651766--- /dev/null+++ b/crates/disktree-core/src/macos.rs@@ -0,0 +1,619 @@+//! What a walk on macOS needs beyond the standard library.+//!+//! `std::fs::read_dir` lists a directory with `readdir`, whose records carry+//! a name and a type, and `DirEntry::metadata` is then an `lstat` of each+//! entry's full path. `getattrlistbulk(2)` returns every entry's size,+//! identity, age and flags for a whole buffer of entries, without the kernel+//! setting up per-file state for each one as a stat must.++#![allow(+ unsafe_code,+ reason = "getattrlistbulk, which neither std nor rustix wraps; each block \+ says why it is sound"+)]++use std::cell::RefCell;+use std::ffi::{OsStr, c_int, c_void};+use std::io;+use std::os::fd::{AsRawFd as _, OwnedFd};+use std::os::unix::ffi::OsStrExt as _;+use std::path::{Path, PathBuf};++use rustix::fs::{AtFlags, FileType, Mode, OFlags};++/// Bytes the kernel fills per call: some hundreds of entries.+const BUFFER_BYTES: usize = 64 * 1024;++// From <sys/attr.h> and <sys/vnode.h>, which the libc crate does not cover.+const ATTR_BIT_MAP_COUNT: u16 = 5;+const ATTR_CMN_NAME: u32 = 0x0000_0001;+const ATTR_CMN_DEVID: u32 = 0x0000_0002;+const ATTR_CMN_OBJTYPE: u32 = 0x0000_0008;+const ATTR_CMN_MODTIME: u32 = 0x0000_0400;+const ATTR_CMN_FLAGS: u32 = 0x0004_0000;+const ATTR_CMN_FILEID: u32 = 0x0200_0000;+const ATTR_CMN_ERROR: u32 = 0x2000_0000;+const ATTR_CMN_RETURNED_ATTRS: u32 = 0x8000_0000;+const ATTR_FILE_LINKCOUNT: u32 = 0x0000_0001;+/// Every fork, which is what `st_blocks` counts: a resource fork is on the+/// disk too.+const ATTR_FILE_ALLOCSIZE: u32 = 0x0000_0004;+/// The data fork alone, which is what `st_size` is.+const ATTR_FILE_DATALENGTH: u32 = 0x0000_0200;+const VREG: u32 = 1;+const VDIR: u32 = 2;+const VLNK: u32 = 5;+/// `SF_DATALESS` from <sys/stat.h>.+const SF_DATALESS: u32 = 0x4000_0000;++const COMMON_ATTRIBUTES: u32 = ATTR_CMN_RETURNED_ATTRS+ | ATTR_CMN_NAME+ | ATTR_CMN_DEVID+ | ATTR_CMN_OBJTYPE+ | ATTR_CMN_MODTIME+ | ATTR_CMN_FLAGS+ | ATTR_CMN_FILEID+ | ATTR_CMN_ERROR;+const FILE_ATTRIBUTES: u32 =+ ATTR_FILE_LINKCOUNT | ATTR_FILE_ALLOCSIZE | ATTR_FILE_DATALENGTH;+/// What [`Cursor::entry`] reads after the name; a file system may leave+/// any of them out.+const MEASURED: u32 = ATTR_CMN_DEVID+ | ATTR_CMN_OBJTYPE+ | ATTR_CMN_MODTIME+ | ATTR_CMN_FLAGS+ | ATTR_CMN_FILEID;++#[repr(C)]+struct AttrList {+ bitmapcount: u16,+ reserved: u16,+ commonattr: u32,+ volattr: u32,+ dirattr: u32,+ fileattr: u32,+ forkattr: u32,+}++unsafe extern "C" {+ fn getattrlistbulk(+ dirfd: c_int,+ attr_list: *mut AttrList,+ attr_buf: *mut c_void,+ attr_buf_size: usize,+ options: u64,+ ) -> c_int;+}++thread_local! {+ /// The last finished listing's buffer, for the next one on this thread:+ /// a walk lists millions of directories, one at a time per thread.+ static SPARE: RefCell<Option<Box<[u64]>>> = const { RefCell::new(None) };+}++/// What an entry is.+#[derive(Clone, Copy, Debug, PartialEq, Eq)]+pub enum Kind {+ Directory,+ Link,+ File,+ /// A FIFO, a socket or a device node.+ Other,+}++/// One directory entry, with what a measurement needs.+#[derive(Debug)]+pub struct Entry {+ name: Box<str>,+ /// The name as the file system spells it, only when `name` could not:+ /// a name that is not UTF-8 is shown lossy but must still open.+ exact: Option<Box<OsStr>>,+ kind: Kind,+ apparent: u64,+ allocated: u64,+ modified: i64,+ device: u64,+ inode: u64,+ links: u32,+ flags: u32,+}++impl Entry {+ /// The entry's path inside `dir`, the directory it was listed from.+ pub fn path(&self, dir: &Path) -> PathBuf {+ dir.join(self.file_name())+ }++ pub fn file_name(&self) -> &OsStr {+ self.exact+ .as_deref()+ .unwrap_or_else(|| OsStr::new(&*self.name))+ }++ /// The name as text; see [`Self::file_name`] for what it may lose.+ pub fn name(&self) -> &str {+ &self.name+ }++ /// The name, moved out: the tree keeps it, so nothing copies it. The+ /// entry's other accessors keep working; `name`, `file_name` and+ /// `path` do not.+ pub fn take_name(&mut self) -> Box<str> {+ std::mem::take(&mut self.name)+ }++ pub const fn kind(&self) -> Kind {+ self.kind+ }++ /// `st_size`.+ pub const fn apparent(&self) -> u64 {+ self.apparent+ }++ /// `st_blocks * 512`.+ pub const fn allocated(&self) -> u64 {+ self.allocated+ }++ /// Last write, in Unix seconds.+ pub const fn modified(&self) -> i64 {+ self.modified+ }++ /// `(st_dev, st_ino)`: the same for two names of one file.+ pub const fn identity(&self) -> (u64, u64) {+ (self.device, self.inode)+ }++ pub const fn device(&self) -> u64 {+ self.device+ }++ /// Whether the file has more than one name.+ pub const fn shared(&self) -> bool {+ self.links > 1+ }++ /// Whether this is a directory iCloud Drive or a File Provider has+ /// evicted, which listing would make it fetch.+ pub const fn evicted(&self) -> bool {+ matches!(self.kind, Kind::Directory) && self.flags & SF_DATALESS != 0+ }++ fn named(name: &[u8]) -> (Box<str>, Option<Box<OsStr>>) {+ match std::str::from_utf8(name) {+ Ok(text) => (text.into(), None),+ Err(_) => (+ String::from_utf8_lossy(name).into(),+ Some(OsStr::from_bytes(name).into()),+ ),+ }+ }++ fn from_stat(name: &[u8], stat: &rustix::fs::Stat) -> Self {+ let (name, exact) = Self::named(name);+ let kind = match FileType::from_raw_mode(stat.st_mode) {+ FileType::Directory => Kind::Directory,+ FileType::Symlink => Kind::Link,+ FileType::RegularFile => Kind::File,+ _ => Kind::Other,+ };+ Self {+ name,+ exact,+ kind,+ apparent: stat.st_size.max(0) as u64,+ allocated: (stat.st_blocks.max(0) as u64).saturating_mul(512),+ modified: stat.st_mtime,+ device: i64::from(stat.st_dev).cast_unsigned(),+ inode: stat.st_ino,+ links: u32::from(stat.st_nlink),+ flags: stat.st_flags,+ }+ }+}++/// A directory being listed; like `std::fs::ReadDir`, it leaves out `.`+/// and `..`.+#[derive(Debug)]+pub struct ReadDir {+ fd: OwnedFd,+ /// `u64`s for alignment; the records themselves are 4-byte aligned.+ buffer: Option<Box<[u64]>>,+ /// Records in the buffer not yet handed out.+ remaining: u32,+ /// Where the next of them starts.+ offset: usize,+ done: bool,+}++/// List `dir`, with each entry's size, identity and age. A link at `dir`+/// itself is followed, as `std::fs::read_dir` follows it.+pub fn read_dir(dir: &Path) -> io::Result<ReadDir> {+ let fd = rustix::fs::open(+ dir,+ OFlags::RDONLY | OFlags::DIRECTORY | OFlags::CLOEXEC,+ Mode::empty(),+ )?;+ let buffer = SPARE+ .with_borrow_mut(Option::take)+ .unwrap_or_else(|| vec![0; BUFFER_BYTES / 8].into_boxed_slice());+ Ok(ReadDir {+ fd,+ buffer: Some(buffer),+ remaining: 0,+ offset: 0,+ done: false,+ })+}++impl Drop for ReadDir {+ fn drop(&mut self) {+ if let Some(buffer) = self.buffer.take() {+ SPARE.with_borrow_mut(|spare| *spare = Some(buffer));+ }+ }+}++impl Iterator for ReadDir {+ type Item = io::Result<Entry>;++ fn next(&mut self) -> Option<Self::Item> {+ if self.remaining == 0 {+ if self.done {+ return None;+ }+ match self.fill() {+ Ok(0) => {+ self.done = true;+ return None;+ }+ Ok(count) => {+ self.remaining = count;+ self.offset = 0;+ }+ Err(error) => {+ self.done = true;+ return Some(Err(error));+ }+ }+ }+ self.remaining -= 1;+ match self.record() {+ Ok((entry, length)) => {+ self.offset += length;+ Some(entry)+ }+ Err(error) => {+ self.remaining = 0;+ self.done = true;+ Some(Err(error))+ }+ }+ }+}++impl ReadDir {+ /// Ask the kernel for the next buffer of records; how many it wrote.+ fn fill(&mut self) -> io::Result<u32> {+ let buffer = self.buffer.as_mut().expect("held until drop");+ let mut request = AttrList {+ bitmapcount: ATTR_BIT_MAP_COUNT,+ reserved: 0,+ commonattr: COMMON_ATTRIBUTES,+ volattr: 0,+ dirattr: 0,+ fileattr: FILE_ATTRIBUTES,+ forkattr: 0,+ };+ loop {+ // SAFETY: the descriptor is an open directory owned by `self`;+ // `request` is a valid attrlist for the call's duration; and the+ // pointer and length describe `buffer`, which is writable for+ // that many bytes and not otherwise borrowed during the call.+ let count = unsafe {+ getattrlistbulk(+ self.fd.as_raw_fd(),+ &raw mut request,+ buffer.as_mut_ptr().cast(),+ BUFFER_BYTES,+ 0,+ )+ };+ if let Ok(count) = u32::try_from(count) {+ return Ok(count);+ }+ let error = io::Error::last_os_error();+ if error.kind() != io::ErrorKind::Interrupted {+ return Err(error);+ }+ }+ }++ /// The buffer as the bytes the kernel wrote.+ fn bytes(&self) -> &[u8] {+ let buffer = self.buffer.as_deref().expect("held until drop");+ // SAFETY: `[u64]` can be read as `u8`s of eight times its length:+ // one allocation, no alignment requirement for `u8`, and every byte+ // initialized, since the buffer starts zeroed.+ unsafe {+ std::slice::from_raw_parts(+ buffer.as_ptr().cast::<u8>(),+ size_of_val(buffer),+ )+ }+ }++ /// The entry at `self.offset` and the record's length. Every length and+ /// offset the kernel wrote is checked against the buffer before it is+ /// used.+ ///+ /// Layout per getattrlist(2): a `u32` length, the returned+ /// `attribute_set_t`, `ATTR_CMN_ERROR` when it is set, then every other+ /// attribute in bit order, each packed at 4-byte alignment.+ fn record(&self) -> io::Result<(io::Result<Entry>, usize)> {+ let bytes = self.bytes();+ let length = read_u32(bytes, self.offset)? as usize;+ let record = bytes+ .get(self.offset..self.offset + length)+ .ok_or_else(malformed)?;+ let mut cursor = Cursor { record, at: 4 };+ let common = cursor.u32()?;+ cursor.at += 8;+ let file = cursor.u32()?;+ cursor.at += 4;+ let error = if common & ATTR_CMN_ERROR == 0 {+ 0+ } else {+ cursor.u32()?+ };+ let name = cursor.name()?;+ if error != 0 {+ let error = io::Error::from_raw_os_error(error.cast_signed());+ return Ok((Err(error), length));+ }+ let entry = if common & MEASURED == MEASURED {+ cursor.entry(file, name)?+ } else {+ None+ };+ Ok((entry.map_or_else(|| self.stat(name), Ok), length))+ }++ /// An entry the file system described only in part, read the ordinary+ /// way, relative to the directory already open.+ fn stat(&self, name: &[u8]) -> io::Result<Entry> {+ let stat =+ rustix::fs::statat(&self.fd, name, AtFlags::SYMLINK_NOFOLLOW)?;+ Ok(Entry::from_stat(name, &stat))+ }+}++fn malformed() -> io::Error {+ io::Error::other("the kernel returned a malformed record")+}++fn read_u32(bytes: &[u8], at: usize) -> io::Result<u32> {+ let field = at+ .checked_add(4)+ .and_then(|end| bytes.get(at..end))+ .ok_or_else(malformed)?;+ Ok(u32::from_ne_bytes(+ field.try_into().map_err(|_| malformed())?,+ ))+}++/// Reads a record's attributes in order; reading past its end is a+/// malformed record.+struct Cursor<'a> {+ record: &'a [u8],+ at: usize,+}++impl<'a> Cursor<'a> {+ fn u32(&mut self) -> io::Result<u32> {+ let value = read_u32(self.record, self.at)?;+ self.at += 4;+ Ok(value)+ }++ fn u64(&mut self) -> io::Result<u64> {+ let field = self+ .at+ .checked_add(8)+ .and_then(|end| self.record.get(self.at..end))+ .ok_or_else(malformed)?;+ self.at += 8;+ Ok(u64::from_ne_bytes(+ field.try_into().map_err(|_| malformed())?,+ ))+ }++ /// An `attrreference_t`: an offset from itself and a length that counts+ /// the terminating NUL.+ fn name(&mut self) -> io::Result<&'a [u8]> {+ let reference = self.at;+ let offset = isize::try_from(self.u32()?.cast_signed())+ .map_err(|_| malformed())?;+ let length = self.u32()? as usize;+ reference+ .checked_add_signed(offset)+ .zip(length.checked_sub(1))+ .and_then(|(start, length)| {+ self.record.get(start..start.checked_add(length)?)+ })+ .ok_or_else(malformed)+ }++ /// The attributes after the name, every one of them asked for; `None`+ /// for a file whose sizes the file system left out.+ fn entry(&mut self, file: u32, name: &[u8]) -> io::Result<Option<Entry>> {+ let device = self.u32()?.cast_signed();+ let kind = match self.u32()? {+ VDIR => Kind::Directory,+ VLNK => Kind::Link,+ VREG => Kind::File,+ _ => Kind::Other,+ };+ let modified = self.u64()?.cast_signed();+ self.at += 8;+ let flags = self.u32()?;+ let inode = self.u64()?;+ // A directory's own size is never measured; its entries are.+ let (links, allocated, apparent) = if kind == Kind::Directory {+ (1, 0, 0)+ } else if file & FILE_ATTRIBUTES == FILE_ATTRIBUTES {+ (self.u32()?, self.u64()?, self.u64()?)+ } else {+ return Ok(None);+ };+ let (name, exact) = Entry::named(name);+ Ok(Some(Entry {+ name,+ exact,+ kind,+ apparent,+ allocated,+ modified,+ device: i64::from(device).cast_unsigned(),+ inode,+ links,+ flags,+ }))+ }+}++#[cfg(test)]+mod tests {+ use super::*;+ use std::fs;+ use std::os::unix::fs::symlink;+ use tempfile::TempDir;++ fn listed(dir: &Path) -> Vec<Entry> {+ let mut entries: Vec<Entry> = read_dir(dir)+ .expect("list")+ .collect::<io::Result<_>>()+ .expect("entries");+ entries.sort_by(|left, right| left.name.cmp(&right.name));+ entries+ }++ /// What `lstat` says of each entry, the way the standard listing reads it.+ fn stated(dir: &Path) -> Vec<Entry> {+ let mut entries: Vec<Entry> = fs::read_dir(dir)+ .expect("list")+ .map(|entry| {+ let entry = entry.expect("entry");+ let stat = rustix::fs::lstat(entry.path()).expect("lstat");+ Entry::from_stat(entry.file_name().as_bytes(), &stat)+ })+ .collect();+ entries.sort_by(|left, right| left.name.cmp(&right.name));+ entries+ }++ type Fields = (String, Kind, u64, u64, i64, (u64, u64), bool, bool);++ /// What the walk reads of a leaf.+ fn fields(entry: &Entry) -> Fields {+ (+ entry.name.to_string(),+ entry.kind,+ entry.apparent,+ entry.allocated,+ entry.modified,+ entry.identity(),+ entry.shared(),+ entry.evicted(),+ )+ }++ #[test]+ fn a_listing_has_names_kinds_lengths_and_no_dot_entries() {+ let temp = TempDir::new().expect("tempdir");+ fs::create_dir(temp.path().join("sub")).expect("mkdir");+ fs::write(temp.path().join("data.bin"), vec![7_u8; 100_000])+ .expect("write");+ symlink("data.bin", temp.path().join("link")).expect("symlink");++ let entries = listed(temp.path());+ let names: Vec<&OsStr> = entries.iter().map(Entry::file_name).collect();+ assert_eq!(names, ["data.bin", "link", "sub"]);+ assert_eq!(entries[0].kind(), Kind::File);+ assert_eq!(entries[0].apparent(), 100_000);+ assert_eq!(entries[0].path(temp.path()), temp.path().join("data.bin"));+ assert_eq!(entries[1].kind(), Kind::Link);+ assert_eq!(entries[2].kind(), Kind::Directory);+ assert!(entries[0].modified() > 0, "written just now");+ }++ #[test]+ fn every_leaf_reads_as_lstat_reads_it() {+ let temp = TempDir::new().expect("tempdir");+ let root = temp.path();+ fs::write(root.join("plain"), b"hi").expect("write");+ fs::hard_link(root.join("plain"), root.join("hard")).expect("link");+ // Ten megabytes long, nothing written: no blocks.+ fs::File::create(root.join("sparse"))+ .and_then(|file| file.set_len(10 << 20))+ .expect("sparse");+ symlink("plain", root.join("link")).expect("symlink");+ // A resource fork, which `st_blocks` counts and `st_size` does not.+ let forked = root.join("forked");+ fs::write(&forked, b"data").expect("write");+ rustix::fs::setxattr(+ &forked,+ "com.apple.ResourceFork",+ &vec![b'r'; 20_000],+ rustix::fs::XattrFlags::empty(),+ )+ .expect("resource fork");++ let listed: Vec<Fields> = listed(root).iter().map(fields).collect();+ let stated: Vec<Fields> = stated(root).iter().map(fields).collect();+ assert_eq!(listed, stated);+ let forked = listed.iter().find(|leaf| leaf.0 == "forked").unwrap();+ assert_eq!(forked.2, 4, "the data fork's length");+ assert!(forked.3 >= 20_000, "the fork's blocks: {}", forked.3);+ let plain = listed.iter().find(|leaf| leaf.0 == "plain").unwrap();+ assert!(plain.6, "two names");+ }++ #[test]+ fn a_directory_larger_than_the_buffer_is_listed_whole() {+ let temp = TempDir::new().expect("tempdir");+ // About a hundred bytes a record: several fills.+ let count = 3 * BUFFER_BYTES / 100;+ for index in 0..count {+ fs::write(temp.path().join(format!("file-{index:05}")), b"")+ .expect("write");+ }+ let entries = listed(temp.path());+ assert_eq!(entries.len(), count);+ assert_eq!(entries[0].name(), "file-00000");+ assert_eq!(entries[count - 1].name(), format!("file-{:05}", count - 1));+ }++ #[test]+ fn names_are_text_and_open() {+ let temp = TempDir::new().expect("tempdir");+ for name in ["café", "日本語", "with space", "a\nb"] {+ fs::write(temp.path().join(name), b"x").expect("write");+ }+ let entries = listed(temp.path());+ assert_eq!(entries.len(), 4);+ for entry in entries {+ assert!(entry.exact.is_none(), "{}", entry.name());+ assert!(fs::metadata(entry.path(temp.path())).is_ok());+ }+ }++ #[test]+ fn a_missing_directory_is_an_error() {+ let temp = TempDir::new().expect("tempdir");+ let error = read_dir(&temp.path().join("gone")).expect_err("missing");+ assert_eq!(error.kind(), io::ErrorKind::NotFound);+ }+}diff --git a/crates/disktree-core/src/scan.rs b/crates/disktree-core/src/scan.rsindex 191f280..3763920 100644--- a/crates/disktree-core/src/scan.rs+++ b/crates/disktree-core/src/scan.rs@@ -15,7 +15,7 @@//! poll without locking, and cooperative cancellation so a re-scan can abandon//! a walk of a large home directory instead of queueing behind it.-#[cfg(not(windows))]+#[cfg(not(any(windows, target_os = "macos")))]use std::fs::DirEntry;use std::fs::{self, Metadata};use std::io;@@ -468,10 +468,12 @@ impl WalkContext {/// What the walk reads about one directory entry.///-/// `std::fs::DirEntry` everywhere but Windows. There the standard listing-/// has neither the allocated size nor a file id, so measuring like `du`-/// would cost an open per file; [`crate::windows`] lists a directory with-/// both instead.+/// `std::fs::DirEntry` everywhere but Windows and macOS. On Windows the+/// standard listing has neither the allocated size nor a file id, so+/// measuring like `du` would cost an open per file; [`crate::windows`] lists+/// a directory with both instead. On macOS it would cost an `lstat` per+/// entry, and [`crate::macos`] lists a directory with everything a stat+/// says.trait Listed {/// The entry's path inside `dir`, the directory it was listed from.fn entry_path(&self, dir: &Path) -> PathBuf;@@ -488,7 +490,8 @@ trait Listed {fn directory(&self) -> io::Result<Directory>;/// Hidden by an attribute rather than by a leading dot: on Windows,/// where the listing carries it, so `AppData` is hidden as Explorer- /// hides it. macOS's `UF_HIDDEN` would cost a stat per entry.+ /// hides it. Finder's `UF_HIDDEN` is not asked for: on macOS, hidden+ /// means a leading dot, as on Linux.fn hidden(&self) -> bool {false}@@ -539,13 +542,13 @@ impl Facts {}/// A standard directory entry with its name decoded once, up front.-#[cfg(not(windows))]+#[cfg(not(any(windows, target_os = "macos")))]struct Named {entry: DirEntry,name: Box<str>,}-#[cfg(not(windows))]+#[cfg(not(any(windows, target_os = "macos")))]impl Listed for Named {fn entry_path(&self, _dir: &Path) -> PathBuf {self.entry.path()@@ -586,6 +589,50 @@ impl Listed for Named {}}+#[cfg(target_os = "macos")]+impl Listed for crate::macos::Entry {+ fn entry_path(&self, dir: &Path) -> PathBuf {+ self.path(dir)+ }++ fn name(&self) -> &str {+ self.name()+ }++ fn take_name(&mut self) -> Box<str> {+ self.take_name()+ }++ fn listing(&self) -> io::Result<Listing> {+ Ok(match self.kind() {+ crate::macos::Kind::Link => Listing::Symlink,+ crate::macos::Kind::Directory => Listing::Directory,+ crate::macos::Kind::File => Listing::Leaf(NodeKind::File),+ crate::macos::Kind::Other => Listing::Leaf(NodeKind::Other),+ })+ }++ fn facts(&self, apparent_size: bool) -> io::Result<Facts> {+ Ok(Facts {+ size: if apparent_size {+ self.apparent()+ } else {+ self.allocated()+ },+ identity: Some(self.identity()),+ modified: self.modified(),+ shared: self.shared(),+ })+ }++ fn directory(&self) -> io::Result<Directory> {+ Ok(Directory {+ device: self.device(),+ evicted: self.evicted(),+ })+ }+}+#[cfg(windows)]impl Listed for crate::windows::Entry {fn entry_path(&self, dir: &Path) -> PathBuf {@@ -639,7 +686,7 @@ impl Listed for crate::windows::Entry {}/// List a directory the way [`Listed`] describes.-#[cfg(not(windows))]+#[cfg(not(any(windows, target_os = "macos")))]fn list(path: &Path,_volume: Option<u64>,@@ -655,6 +702,14 @@ fn list(}))}+#[cfg(target_os = "macos")]+fn list(+ path: &Path,+ _volume: Option<u64>,+) -> io::Result<crate::macos::ReadDir> {+ crate::macos::read_dir(path)+}+#[cfg(windows)]fn list(path: &Path,