feat(report): add cargo report rebuilds (#16456)

### What does this PR try to resolve?

This will improve <#2904>.

Part of <#15844>.

Adds a new command to analyze rebuild reasons from previous sessions.

The report includes:

* overview of rebuild/cached/new unit counts
* root rebuilds sorted by number of cascading rebuilds
* `-v`  to show all root rebuilds (default showing 5)
* `-vv` to show affected unit lists (default collapsed)

This command doesn't have filtering by package or reason yet.
Can be added when we have use cases.

Example output:

```console
Session: 20251231T204416809Z-a5db680cc3bc96e4
Status: 3 units rebuilt, 0 cached, 0 new

Rebuild impact:
  root rebuilds: 1 unit
  cascading:     2 units

Root rebuilds:
  0. [email protected] (check): file modified: common/src/lib.rs
     impact: 2 dependent units rebuilt

[NOTE] pass `-vv` to show all affected rebuilt unit lists
```

```console
$ cargo report rebuilds --verbose`
Session: 20251231T204416809Z-a5db680cc3bc96e4
Status: 6 units rebuilt, 0 cached, 0 new

Rebuild impact:
  root rebuilds: 6 units
  cascading:     0 units

Root rebuilds:
  0. [email protected] (check): declared features changed: [] -> ["feat"]
     impact: no cascading rebuilds
  1. [email protected] (check): file modified: pkg2/src/lib.rs
     impact: no cascading rebuilds
  2. [email protected] (check): target configuration changed
     impact: no cascading rebuilds
  3. [email protected] (check): environment variable changed (__CARGO_TEST_MY_FOO): <unset> -> 1
     impact: no cascading rebuilds
  4. [email protected] (check): file modified: pkg5/src/lib.rs
     impact: no cascading rebuilds
  5. [email protected] (check): file modified: pkg6/src/lib.rs
     impact: no cascading rebuilds
```

### How to test and review this PR?

I found it awkward to logging fingerprint,
at least haven't found a reason way to implement that.
This came out first as a basic version of rebuild reporting.

### Open questions

* Should this show a tree view like `cargo tree`?
* Personally I think `cargo report builds` rignt how should have only a
basic version to show the usefulness of log messages, and we can expand
later if needed.
* Should we also show cached unit?
* Probably not. I aim to provide a command to answer the most frequently
asked question: What is the root cause of this rebuild. While some of
the info is not really useful and has no follow-up user action, we can
improve them later when dirty reason become more exposed to users.

### Screenshots

Built rustfix after `cargo update syn@2`

<img width="497" height="231" alt="image"
src="https://github.com/user-attachments/assets/50fc6291-0741-46be-8297-2b21d508d557"
/>

<img width="391" height="280" alt="image"
src="https://github.com/user-attachments/assets/03fa147d-b0c8-450f-8d57-4741ceefe6be"
/>

Author: epage

src/bin/cargo/commands/report.rs

@@ -44,6 +44,11 @@ pub fn cli() -> Command {
                         .default_value("10"),
                 ),
         )
+        .subcommand(
+            subcommand("rebuilds")
+                .about("Reports rebuild reasons from previous sessions (unstable)")
+                .arg_manifest_path(),
+        )
 }
 
 pub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {
@@ -75,6 +80,19 @@ pub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {
             ops::report_sessions(gctx, ws.as_ref(), opts)?;
             Ok(())
         }
+        Some(("rebuilds", args)) => {
+            gctx.cli_unstable().fail_if_stable_command(
+                gctx,
+                "report rebuilds",
+                15844,
+                "build-analysis",
+                gctx.cli_unstable().build_analysis,
+            )?;
+            let ws = args.workspace(gctx).ok();
+            let opts = rebuilds_opts(args)?;
+            ops::report_rebuilds(gctx, ws.as_ref(), opts)?;
+            Ok(())
+        }
         Some((cmd, _)) => {
             unreachable!("unexpected command {}", cmd)
         }
@@ -112,3 +130,7 @@ fn sessions_opts(args: &ArgMatches) -> CargoResult<ops::ReportSessionsOptions> {
 
     Ok(ops::ReportSessionsOptions { limit })
 }
+
+fn rebuilds_opts(_args: &ArgMatches) -> CargoResult<ops::ReportRebuildsOptions> {
+    Ok(ops::ReportRebuildsOptions {})
+}

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

@@ -678,6 +678,16 @@ impl Serialize for Checksum {
     }
 }
 
+impl<'de> serde::Deserialize<'de> for Checksum {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let s = String::deserialize(deserializer)?;
+        s.parse().map_err(serde::de::Error::custom)
+    }
+}
+
 #[derive(Debug, thiserror::Error)]
 pub enum InvalidChecksum {
     #[error("algorithm portion incorrect, expected `sha256`, or `blake3`")]

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

@@ -1,3 +1,4 @@
+use std::collections::HashMap;
 use std::fmt;
 use std::fmt::Debug;
 
@@ -10,7 +11,7 @@ use crate::core::Shell;
 /// to a recompile. Usually constructed via [`Fingerprint::compare`].
 ///
 /// [`Fingerprint::compare`]: super::Fingerprint::compare
-#[derive(Clone, Debug, Serialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(tag = "dirty_reason", rename_all = "kebab-case")]
 pub enum DirtyReason {
     RustcChanged,
@@ -61,8 +62,8 @@ pub enum DirtyReason {
         new_value: Option<String>,
     },
     LocalFingerprintTypeChanged {
-        old: &'static str,
-        new: &'static str,
+        old: String,
+        new: String,
     },
     NumberOfDependenciesChanged {
         old: usize,
@@ -73,11 +74,7 @@ pub enum DirtyReason {
         new: InternedString,
     },
     UnitDependencyInfoChanged {
-        old_name: InternedString,
-        old_fingerprint: u64,
-
-        new_name: InternedString,
-        new_fingerprint: u64,
+        unit: u64,
     },
     FsStatusOutdated(FsStatus),
     NothingObvious,
@@ -148,7 +145,13 @@ impl DirtyReason {
         }
     }
 
-    pub fn present_to(&self, s: &mut Shell, unit: &Unit, root: &Path) -> CargoResult<()> {
+    pub fn present_to(
+        &self,
+        s: &mut Shell,
+        unit: &Unit,
+        root: &Path,
+        index_to_unit: &HashMap<u64, Unit>,
+    ) -> CargoResult<()> {
         match self {
             DirtyReason::RustcChanged => s.dirty_because(unit, "the toolchain changed"),
             DirtyReason::FeaturesChanged { .. } => {
@@ -220,8 +223,12 @@ impl DirtyReason {
                 unit,
                 format_args!("name of dependency changed ({old} => {new})"),
             ),
-            DirtyReason::UnitDependencyInfoChanged { .. } => {
-                s.dirty_because(unit, "dependency info changed")
+            DirtyReason::UnitDependencyInfoChanged { unit: dep_unit } => {
+                let dep_name = index_to_unit.get(dep_unit).map(|u| u.pkg.name()).unwrap();
+                s.dirty_because(
+                    unit,
+                    format_args!("info of dependency `{dep_name}` changed"),
+                )
             }
             DirtyReason::FsStatusOutdated(status) => match status {
                 FsStatus::Stale => s.dirty_because(unit, "stale, unknown reason"),
@@ -301,19 +308,23 @@ impl DirtyReason {
                     ),
                 },
                 FsStatus::StaleDependency {
-                    name,
+                    unit: dep_unit,
                     dep_mtime,
                     max_mtime,
-                    ..
                 } => {
+                    let dep_name = index_to_unit.get(dep_unit).map(|u| u.pkg.name()).unwrap();
                     let after = Self::after(*max_mtime, *dep_mtime, "last build");
                     s.dirty_because(
                         unit,
-                        format_args!("the dependency {name} was rebuilt ({after})"),
+                        format_args!("the dependency `{dep_name}` was rebuilt ({after})"),
                     )
                 }
-                FsStatus::StaleDepFingerprint { name } => {
-                    s.dirty_because(unit, format_args!("the dependency {name} was rebuilt"))
+                FsStatus::StaleDepFingerprint { unit: dep_unit } => {
+                    let dep_name = index_to_unit.get(dep_unit).map(|u| u.pkg.name()).unwrap();
+                    s.dirty_because(
+                        unit,
+                        format_args!("the dependency `{dep_name}` was rebuilt"),
+                    )
                 }
                 FsStatus::UpToDate { .. } => {
                     unreachable!()
@@ -529,8 +540,8 @@ mod json_schema {
             str![[r#"
 {
   "dirty_reason": "unit-dependency-name-changed",
-  "old": "old_dep",
-  "new": "new_dep"
+  "new": "new_dep",
+  "old": "old_dep"
 }
 "#]]
             .is_json()
@@ -539,21 +550,13 @@ mod json_schema {
 
     #[test]
     fn unit_dependency_info_changed() {
-        let reason = DirtyReason::UnitDependencyInfoChanged {
-            old_name: "serde".into(),
-            old_fingerprint: 0x1234567890abcdef,
-            new_name: "serde".into(),
-            new_fingerprint: 0xfedcba0987654321,
-        };
+        let reason = DirtyReason::UnitDependencyInfoChanged { unit: 15 };
         assert_data_eq!(
             to_json(&reason),
             str![[r#"
 {
   "dirty_reason": "unit-dependency-info-changed",
-  "new_fingerprint": 18364757930599072545,
-  "new_name": "serde",
-  "old_fingerprint": 1311768467294899695,
-  "old_name": "serde"
+  "unit": 15
 }
 "#]]
             .is_json()
@@ -647,7 +650,7 @@ mod json_schema {
     #[test]
     fn fs_status_stale_dependency() {
         let reason = DirtyReason::FsStatusOutdated(FsStatus::StaleDependency {
-            name: "serde".into(),
+            unit: 42,
             dep_mtime: FileTime::from_unix_time(1730567892, 789000000),
             max_mtime: FileTime::from_unix_time(1730567890, 123000000),
         });
@@ -659,7 +662,7 @@ mod json_schema {
   "dirty_reason": "fs-status-outdated",
   "fs_status": "stale-dependency",
   "max_mtime": 1730567890123.0,
-  "name": "serde"
+  "unit": 42
 }
 "#]]
             .is_json()
@@ -668,16 +671,14 @@ mod json_schema {
 
     #[test]
     fn fs_status_stale_dep_fingerprint() {
-        let reason = DirtyReason::FsStatusOutdated(FsStatus::StaleDepFingerprint {
-            name: "tokio".into(),
-        });
+        let reason = DirtyReason::FsStatusOutdated(FsStatus::StaleDepFingerprint { unit: 42 });
         assert_data_eq!(
             to_json(&reason),
             str![[r#"
 {
   "dirty_reason": "fs-status-outdated",
   "fs_status": "stale-dep-fingerprint",
-  "name": "tokio"
+  "unit": 42
 }
 "#]]
             .is_json()
@@ -830,8 +831,8 @@ mod json_schema {
     #[test]
     fn local_fingerprint_type_changed() {
         let reason = DirtyReason::LocalFingerprintTypeChanged {
-            old: "precalculated",
-            new: "rerun-if-changed",
+            old: "precalculated".to_owned(),
+            new: "rerun-if-changed".to_owned(),
         };
         assert_data_eq!(
             to_json(&reason),