fix(hardlink)!: include dev in ReflectionEntry and JSON schema

The Copilot PR kept dev out of the reflection/JSON layer, introducing
a dev=0 placeholder hack, double-allocation sorting, and "unsupported
edge case" disclaimers. Since the reflection is meant to mirror the
internal HardlinkList, just include dev in ReflectionEntry. This
simplifies From<HardlinkList> back to a single-pass map+collect,
removes the dev=0 workaround in TryFrom<Reflection>, and makes
multi-filesystem JSON round-tripping correct.

Bump SCHEMA_VERSION to 2026-04-02 for the new field.

https://claude.ai/code/session_01QP9wZyoZcGmJsEsA66ZRok

Author: claude

src/hardlink/hardlink_list.rs

@@ -27,7 +27,7 @@ use std::path::Path;
 /// the same inode number. Both du-dust and dua-cli track `(device, inode)` pairs
 /// for the same reason.
 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
-struct InodeKey {
+pub(crate) struct InodeKey {
     /// Device number of the filesystem the inode belongs to.
     dev: u64,
     /// Inode number within the device.

src/hardlink/hardlink_list/iter.rs

@@ -30,6 +30,12 @@ impl<'a, Size> Iterator for Iter<'a, Size> {
 }
 
 impl<'a, Size> Item<'a, Size> {
+    /// The device number of the filesystem the inode belongs to.
+    #[inline]
+    pub fn dev(&self) -> u64 {
+        self.0.key().dev
+    }
+
     /// The inode number of the file.
     #[inline]
     pub fn ino(&self) -> InodeNumber {

src/hardlink/hardlink_list/reflection.rs

@@ -12,14 +12,8 @@ use serde::{Deserialize, Serialize};
 /// internal content.
 ///
 /// **Guarantees:**
-/// * Every `(device, inode)` pair is unique within the scope of a single scan, but inode
-///   numbers alone are **not** guaranteed to be unique: when scanning multiple filesystems,
-///   two unrelated files on different devices can share the same inode number and will each
-///   produce a separate entry. The reflection stores only the inode number (the JSON format
-///   does not carry device information), so round-tripping a multi-filesystem scan through
-///   JSON is an unsupported edge case.
-/// * The internal list is always sorted by inode numbers (and by device number as a
-///   tie-breaker when two entries share the same inode number).
+/// * Every `(device, inode)` pair is unique.
+/// * The internal list is always sorted by inode numbers (with device number as tie-breaker).
 ///
 /// **Equality:** `Reflection` implements `PartialEq` and `Eq` traits.
 ///
@@ -54,6 +48,8 @@ impl<Size> Reflection<Size> {
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "json", derive(Deserialize, Serialize))]
 pub struct ReflectionEntry<Size> {
+    /// Device number of the filesystem the inode belongs to.
+    pub dev: u64,
     /// The inode number of the file.
     pub ino: InodeNumber,
     /// Size of the file.
@@ -67,51 +63,46 @@ pub struct ReflectionEntry<Size> {
 impl<Size> ReflectionEntry<Size> {
     /// Create a new entry.
     #[inline]
-    fn new(ino: InodeNumber, Value { size, links, paths }: Value<Size>) -> Self {
+    fn new(InodeKey { dev, ino }: InodeKey, Value { size, links, paths }: Value<Size>) -> Self {
         let paths = paths.into();
         ReflectionEntry {
+            dev,
             ino,
             size,
             links,
             paths,
         }
     }
 
-    /// Dissolve [`ReflectionEntry`] into a pair of [`InodeNumber`] and [`Value`].
+    /// Dissolve [`ReflectionEntry`] into a pair of [`InodeKey`] and [`Value`].
     #[inline]
-    fn dissolve(self) -> (InodeNumber, Value<Size>) {
+    fn dissolve(self) -> (InodeKey, Value<Size>) {
         let ReflectionEntry {
+            dev,
             ino,
             size,
             links,
             paths,
         } = self;
         let paths = paths.into();
-        (ino, Value { size, links, paths })
+        (InodeKey { dev, ino }, Value { size, links, paths })
     }
 }
 
 impl<Size> From<Vec<ReflectionEntry<Size>>> for Reflection<Size> {
-    /// Sort the list by inode numbers, then create the reflection.
+    /// Sort the list by `(inode, device)`, then create the reflection.
     fn from(list: Vec<ReflectionEntry<Size>>) -> Self {
-        list.into_sorted_unstable_by_key(|entry| u64::from(entry.ino))
+        list.into_sorted_unstable_by_key(|entry| (u64::from(entry.ino), entry.dev))
             .pipe(Reflection)
     }
 }
 
 impl<Size> From<HardlinkList<Size>> for Reflection<Size> {
     fn from(HardlinkList(list): HardlinkList<Size>) -> Self {
-        // Collect to a vec, sort by (ino, dev) for a stable, deterministic order, then
-        // strip dev before wrapping.  Sorting here (with dev still available) avoids the
-        // nondeterminism that would arise from an unstable sort on ino alone when two
-        // entries from different filesystems share the same inode number.
-        let mut pairs: Vec<(InodeKey, Value<Size>)> = list.into_iter().collect();
-        pairs.sort_unstable_by_key(|(key, _)| (u64::from(key.ino), key.dev));
-        pairs
-            .into_iter()
-            .map(|(key, value)| ReflectionEntry::new(key.ino, value))
+        list.into_iter()
+            .map(|(key, value)| ReflectionEntry::new(key, value))
             .collect::<Vec<_>>()
-            .pipe(Reflection)
+            .pipe(Reflection::from)
     }
 }
 
@@ -131,17 +122,9 @@ impl<Size> TryFrom<Reflection<Size>> for HardlinkList<Size> {
         let map = DashMap::with_capacity(entries.len());
 
         for entry in entries {
-            let (ino, value) = entry.dissolve();
-            // Device number is unknown when loading from a reflection (e.g. JSON input);
-            // use dev=0 as a placeholder. This means that when reloading JSON output that
-            // was produced by scanning multiple filesystems, files from different devices
-            // sharing the same inode number cannot be distinguished and therefore cannot
-            // all be represented. Such duplicates cause a ConversionError::DuplicatedInode
-            // and are treated as an unsupported edge case, since the JSON format does not
-            // carry device information.
-            let key = InodeKey { dev: 0, ino };
+            let (key, value) = entry.dissolve();
             if map.insert(key, value).is_some() {
-                return ino.pipe(ConversionError::DuplicatedInode).pipe(Err);
+                return key.ino.pipe(ConversionError::DuplicatedInode).pipe(Err);
             }
         }
 

src/hardlink/hardlink_list/test.rs

@@ -174,12 +174,14 @@ fn same_ino_on_different_devices_are_treated_separately() {
     assert_eq!(list.len(), 2, "expected one entry per (dev, ino) pair");
 
     let reflection = list.into_reflection();
-    // Both entries expose ino=100 in the reflection (device is not part of the
-    // public JSON format), so there are still 2 entries in the vector.
     assert_eq!(reflection.len(), 2);
 
-    // Paths are grouped per (dev, ino): each group has exactly 2 paths.
-    for entry in reflection.iter() {
-        assert_eq!(entry.paths.len(), 2);
-    }
+    // Sorted by (ino, dev), so dev=1 comes first.
+    let entries: Vec<_> = reflection.iter().collect();
+    assert_eq!(entries[0].dev, 1);
+    assert_eq!(entries[0].ino, 100.into());
+    assert_eq!(entries[0].paths.len(), 2);
+    assert_eq!(entries[1].dev, 2);
+    assert_eq!(entries[1].ino, 100.into());
+    assert_eq!(entries[1].paths.len(), 2);
 }

src/json_data/schema_version.rs

@@ -6,7 +6,7 @@ use serde::{Deserialize, Serialize};
 use std::convert::TryFrom;
 
 /// Content of [`SchemaVersion`].
-pub const SCHEMA_VERSION: &str = "2024-11-02";
+pub const SCHEMA_VERSION: &str = "2026-04-02";
 
 /// Verifying schema version.
 #[derive(Debug, Clone, Copy)]

tests/_utils.rs

@@ -583,3 +583,12 @@ pub fn read_inode_number(path: &Path) -> u64 {
         .unwrap_or_else(|error| panic!("Can't read metadata at {path:?}: {error}"))
         .ino()
 }
+
+/// Read [dev](std::os::unix::fs::MetadataExt::dev) of a path.
+#[cfg(unix)]
+pub fn read_device_number(path: &Path) -> u64 {
+    use std::os::unix::fs::MetadataExt;
+    path.pipe(symlink_metadata)
+        .unwrap_or_else(|error| panic!("Can't read metadata at {path:?}: {error}"))
+        .dev()
+}

tests/hardlinks_deduplication.rs

@@ -85,6 +85,8 @@ fn simple_tree_with_some_hardlinks() {
             .pipe(InodeNumber::from)
     };
 
+    let dev = read_device_number(&workspace);
+
     let shared_paths = |suffices: &[&str]| {
         suffices
             .iter()
@@ -190,6 +192,7 @@ fn simple_tree_with_some_hardlinks() {
         .collect();
     let expected_shared_details = [
         ReflectionEntry {
+            dev,
             ino: file_inode("one-internal-hardlink.txt"),
             size: file_size("one-internal-hardlink.txt"),
             links: 1 + 1,
@@ -199,6 +202,7 @@ fn simple_tree_with_some_hardlinks() {
             ]),
         },
         ReflectionEntry {
+            dev,
             ino: file_inode("two-internal-hardlinks.txt"),
             size: file_size("two-internal-hardlinks.txt"),
             links: 1 + 2,
@@ -209,12 +213,14 @@ fn simple_tree_with_some_hardlinks() {
             ]),
         },
         ReflectionEntry {
+            dev,
             ino: file_inode("one-external-hardlink.txt"),
             size: file_size("one-external-hardlink.txt"),
             links: 1 + 1,
             paths: shared_paths(&["sources/one-external-hardlink.txt"]),
         },
         ReflectionEntry {
+            dev,
             ino: file_inode("one-internal-one-external-hardlinks.txt"),
             size: file_size("one-internal-one-external-hardlinks.txt"),
             links: 1 + 1 + 1,
@@ -338,6 +344,8 @@ fn multiple_hardlinks_to_a_single_file() {
         .pipe_as_ref(read_inode_number)
         .pipe(InodeNumber::from);
 
+    let dev = read_device_number(&workspace);
+
     let actual_size = tree.size;
     let expected_size = workspace
         .pipe_as_ref(read_apparent_size)
@@ -374,6 +382,7 @@ fn multiple_hardlinks_to_a_single_file() {
         .cloned()
         .collect();
     let expected_shared_details = [ReflectionEntry {
+        dev,
         ino: file_inode,
         size: file_size,
         links: 1 + links,
@@ -470,6 +479,8 @@ fn complex_tree_with_shared_and_unique_files() {
             .pipe(Bytes::new)
     };
 
+    let dev = read_device_number(&workspace);
+
     let actual_size = tree.size;
 
     // The following formula treat the first file as "real" and
@@ -562,6 +573,7 @@ fn complex_tree_with_shared_and_unique_files() {
             .find(|item| starts_with_path(item, "some-hardlinks/file-0.txt"))
             .cloned();
         let expected = Some(ReflectionEntry {
+            dev,
             ino: workspace
                 .join("some-hardlinks/file-0.txt")
                 .pipe_as_ref(read_inode_number)
@@ -591,6 +603,7 @@ fn complex_tree_with_shared_and_unique_files() {
             .find(|item| starts_with_path(item, &format!("some-hardlinks/file-{file_index}.txt")))
             .cloned();
         let expected = Some(ReflectionEntry {
+            dev,
             ino: workspace
                 .join(format!("some-hardlinks/file-{file_index}.txt"))
                 .pipe_as_ref(read_inode_number)
@@ -695,6 +708,8 @@ fn hardlinks_and_non_hardlinks() {
             .pipe(InodeNumber::from)
     };
 
+    let dev = read_device_number(&workspace);
+
     let shared_paths = |file_names: &[&str]| {
         file_names
             .iter()
@@ -717,37 +732,43 @@ fn hardlinks_and_non_hardlinks() {
         .collect();
     let expected_shared_details = [
         ReflectionEntry {
+            dev,
             ino: file_inode("file-0.txt"),
             size: file_size,
             links: 3,
             paths: shared_paths(&["file-0.txt", "link0-file0.txt", "link1-file0.txt"]),
         },
         ReflectionEntry {
+            dev,
             ino: file_inode("file-1.txt"),
             size: file_size,
             links: 2,
             paths: shared_paths(&["file-1.txt", "link0-file1.txt"]),
         },
         // ... file-2.txt and file-3.txt don't have hardlinks so they shouldn't appear here ...
         ReflectionEntry {
+            dev,
             ino: file_inode("file-4.txt"),
             size: file_size,
             links: 2,
             paths: shared_paths(&["file-4.txt"]),
         },
         ReflectionEntry {
+            dev,
             ino: file_inode("file-5.txt"),
             size: file_size,
             links: 2,
             paths: shared_paths(&["file-5.txt"]),
         },
         ReflectionEntry {
+            dev,
             ino: file_inode("file-6.txt"),
             size: file_size,
             links: 2,
             paths: shared_paths(&["file-6.txt"]),
         },
         ReflectionEntry {
+            dev,
             ino: file_inode("file-7.txt"),
             size: file_size,
             links: 2,
@@ -898,6 +919,8 @@ fn exclusive_hardlinks_only() {
             .pipe(InodeNumber::from)
     };
 
+    let dev = read_device_number(&workspace);
+
     let shared_paths = |file_names: &[&str]| {
         file_names
             .iter()
@@ -921,6 +944,7 @@ fn exclusive_hardlinks_only() {
     let expected_shared_details = (0..files_per_branch)
         .par_bridge()
         .map(|index| ReflectionEntry {
+            dev,
             ino: file_inode(&format!("file-{index}.txt")),
             size: file_size,
             links: 2,
@@ -1024,6 +1048,8 @@ fn exclusive_only_and_external_only_hardlinks() {
             .pipe(InodeNumber::from)
     };
 
+    let dev = read_device_number(&workspace);
+
     let shared_paths = |file_names: &[&str]| {
         file_names
             .iter()
@@ -1050,6 +1076,7 @@ fn exclusive_only_and_external_only_hardlinks() {
             (0..(files_per_branch / 2))
                 .par_bridge()
                 .map(|index| ReflectionEntry {
+                    dev,
                     ino: file_inode(&format!("link0-{index}.txt")),
                     size: file_size,
                     links: 2,
@@ -1060,6 +1087,7 @@ fn exclusive_only_and_external_only_hardlinks() {
             ((files_per_branch / 2)..files_per_branch)
                 .par_bridge()
                 .map(|index| ReflectionEntry {
+                    dev,
                     ino: file_inode(&format!("link0-{index}.txt")),
                     size: file_size,
                     links: 2,
@@ -1187,6 +1215,8 @@ fn external_hardlinks_only() {
             .pipe(InodeNumber::from)
     };
 
+    let dev = read_device_number(&workspace);
+
     let shared_paths = |file_names: &[&str]| {
         file_names
             .iter()
@@ -1210,6 +1240,7 @@ fn external_hardlinks_only() {
     let expected_shared_details = (0..files_per_branch)
         .par_bridge()
         .map(|index| ReflectionEntry {
+            dev,
             ino: file_inode(&format!("linkX-{index}.txt")),
             size: file_size,
             links: 2,