refactor(fingerprint): StaleItem enum to struct variants

Converts tuple variants to struct variants with named 'path' field.

This prepares for cleaner JSON serialization
where we can have `{"type":"missing-file","path":"..."}`
instead of needing a generic "data" wrapper.

Author: weihanglo

src/cargo/core/compiler/fingerprint/dirty_reason.rs

@@ -223,22 +223,22 @@ impl DirtyReason {
             DirtyReason::FsStatusOutdated(status) => match status {
                 FsStatus::Stale => s.dirty_because(unit, "stale, unknown reason"),
                 FsStatus::StaleItem(item) => match item {
-                    StaleItem::MissingFile(missing_file) => {
-                        let file = missing_file.strip_prefix(root).unwrap_or(&missing_file);
+                    StaleItem::MissingFile { path } => {
+                        let file = path.strip_prefix(root).unwrap_or(&path);
                         s.dirty_because(
                             unit,
                             format_args!("the file `{}` is missing", file.display()),
                         )
                     }
-                    StaleItem::UnableToReadFile(file) => {
-                        let file = file.strip_prefix(root).unwrap_or(&file);
+                    StaleItem::UnableToReadFile { path } => {
+                        let file = path.strip_prefix(root).unwrap_or(&path);
                         s.dirty_because(
                             unit,
                             format_args!("the file `{}` could not be read", file.display()),
                         )
                     }
-                    StaleItem::FailedToReadMetadata(file) => {
-                        let file = file.strip_prefix(root).unwrap_or(&file);
+                    StaleItem::FailedToReadMetadata { path } => {
+                        let file = path.strip_prefix(root).unwrap_or(&path);
                         s.dirty_because(
                             unit,
                             format_args!("couldn't read metadata for file `{}`", file.display()),
@@ -285,7 +285,7 @@ impl DirtyReason {
                             ),
                         )
                     }
-                    StaleItem::MissingChecksum(path) => {
+                    StaleItem::MissingChecksum { path } => {
                         let file = path.strip_prefix(root).unwrap_or(&path);
                         s.dirty_because(
                             unit,

src/cargo/core/compiler/fingerprint/mod.rs

@@ -773,9 +773,15 @@ enum LocalFingerprint {
 /// See [`FsStatus::StaleItem`].
 #[derive(Clone, Debug)]
 pub enum StaleItem {
-    MissingFile(PathBuf),
-    UnableToReadFile(PathBuf),
-    FailedToReadMetadata(PathBuf),
+    MissingFile {
+        path: PathBuf,
+    },
+    UnableToReadFile {
+        path: PathBuf,
+    },
+    FailedToReadMetadata {
+        path: PathBuf,
+    },
     FileSizeChanged {
         path: PathBuf,
         old_size: u64,
@@ -792,7 +798,9 @@ pub enum StaleItem {
         stored_checksum: Checksum,
         new_checksum: Checksum,
     },
-    MissingChecksum(PathBuf),
+    MissingChecksum {
+        path: PathBuf,
+    },
     ChangedEnv {
         var: String,
         previous: Option<String>,
@@ -854,7 +862,7 @@ impl LocalFingerprint {
             LocalFingerprint::CheckDepInfo { dep_info, checksum } => {
                 let dep_info = build_root.join(dep_info);
                 let Some(info) = parse_dep_info(pkg_root, build_root, &dep_info)? else {
-                    return Ok(Some(StaleItem::MissingFile(dep_info)));
+                    return Ok(Some(StaleItem::MissingFile { path: dep_info }));
                 };
                 for (key, previous) in info.env.iter() {
                     if let Some(value) = pkg.manifest().metadata().env_var(key.as_str()) {
@@ -1170,7 +1178,9 @@ impl Fingerprint {
             let Ok(mtime) = paths::mtime(output) else {
                 // This path failed to report its `mtime`. It probably doesn't
                 // exists, so leave ourselves as stale and bail out.
-                let item = StaleItem::FailedToReadMetadata(output.clone());
+                let item = StaleItem::FailedToReadMetadata {
+                    path: output.clone(),
+                };
                 self.fs_status = FsStatus::StaleItem(item);
                 return Ok(());
             };
@@ -1366,13 +1376,13 @@ impl StaleItem {
     /// that.
     fn log(&self) {
         match self {
-            StaleItem::MissingFile(path) => {
+            StaleItem::MissingFile { path } => {
                 info!("stale: missing {:?}", path);
             }
-            StaleItem::UnableToReadFile(path) => {
+            StaleItem::UnableToReadFile { path } => {
                 info!("stale: unable to read {:?}", path);
             }
-            StaleItem::FailedToReadMetadata(path) => {
+            StaleItem::FailedToReadMetadata { path } => {
                 info!("stale: couldn't read metadata {:?}", path);
             }
             StaleItem::ChangedFile {
@@ -1403,7 +1413,7 @@ impl StaleItem {
                 info!("prior checksum {stored_checksum}");
                 info!("  new checksum {new_checksum}");
             }
-            StaleItem::MissingChecksum(path) => {
+            StaleItem::MissingChecksum { path } => {
                 info!("stale: no prior checksum {:?}", path);
             }
             StaleItem::ChangedEnv {
@@ -1958,8 +1968,13 @@ where
     I: IntoIterator<Item = (P, Option<(u64, Checksum)>)>,
     P: AsRef<Path>,
 {
-    let Ok(reference_mtime) = paths::mtime(reference) else {
-        return Some(StaleItem::MissingFile(reference.to_path_buf()));
+    let reference_mtime = match paths::mtime(reference) {
+        Ok(mtime) => mtime,
+        Err(..) => {
+            return Some(StaleItem::MissingFile {
+                path: reference.to_path_buf(),
+            });
+        }
     };
 
     let skippable_dirs = if let Ok(cargo_home) = home::cargo_home() {
@@ -1985,15 +2000,19 @@ where
         }
         if use_checksums {
             let Some((file_len, prior_checksum)) = prior_checksum else {
-                return Some(StaleItem::MissingChecksum(path.to_path_buf()));
+                return Some(StaleItem::MissingChecksum {
+                    path: path.to_path_buf(),
+                });
             };
             let path_buf = path.to_path_buf();
 
             let path_checksum = match checksum_cache.entry(path_buf) {
                 Entry::Occupied(o) => *o.get(),
                 Entry::Vacant(v) => {
                     let Ok(current_file_len) = fs::metadata(&path).map(|m| m.len()) else {
-                        return Some(StaleItem::FailedToReadMetadata(path.to_path_buf()));
+                        return Some(StaleItem::FailedToReadMetadata {
+                            path: path.to_path_buf(),
+                        });
                     };
                     if current_file_len != file_len {
                         return Some(StaleItem::FileSizeChanged {
@@ -2003,10 +2022,14 @@ where
                         });
                     }
                     let Ok(file) = File::open(path) else {
-                        return Some(StaleItem::MissingFile(path.to_path_buf()));
+                        return Some(StaleItem::MissingFile {
+                            path: path.to_path_buf(),
+                        });
                     };
                     let Ok(checksum) = Checksum::compute(prior_checksum.algo(), file) else {
-                        return Some(StaleItem::UnableToReadFile(path.to_path_buf()));
+                        return Some(StaleItem::UnableToReadFile {
+                            path: path.to_path_buf(),
+                        });
                     };
                     *v.insert(checksum)
                 }
@@ -2024,7 +2047,9 @@ where
                 Entry::Occupied(o) => *o.get(),
                 Entry::Vacant(v) => {
                     let Ok(mtime) = paths::mtime_recursive(path) else {
-                        return Some(StaleItem::MissingFile(path.to_path_buf()));
+                        return Some(StaleItem::MissingFile {
+                            path: path.to_path_buf(),
+                        });
                     };
                     *v.insert(mtime)
                 }