Auto merge of #13561 - epage:msrv-report, r=weihanglo

feat: Report some dependency changes on any command

### What does this PR try to resolve?

The goal is to help users be informed when they are held back by either MSRV or semver.

Fixes #13539

### How should we test and review this PR?

### Additional information

Author: bors

crates/cargo-test-support/src/compare.rs

@@ -204,6 +204,7 @@ fn substitute_macros(input: &str) -> String {
         ("[SCRAPING]", "    Scraping"),
         ("[FRESH]", "       Fresh"),
         ("[DIRTY]", "       Dirty"),
+        ("[LOCKING]", "     Locking"),
         ("[UPDATING]", "    Updating"),
         ("[ADDING]", "      Adding"),
         ("[REMOVING]", "    Removing"),

src/cargo/ops/cargo_generate_lockfile.rs

@@ -10,7 +10,6 @@ use crate::util::cache_lock::CacheLockMode;
 use crate::util::context::GlobalContext;
 use crate::util::style;
 use crate::util::CargoResult;
-use anstyle::Style;
 use std::cmp::Ordering;
 use std::collections::{BTreeMap, HashSet};
 use tracing::debug;
@@ -26,17 +25,19 @@ pub struct UpdateOptions<'a> {
 
 pub fn generate_lockfile(ws: &Workspace<'_>) -> CargoResult<()> {
     let mut registry = PackageRegistry::new(ws.gctx())?;
+    let previous_resolve = None;
     let mut resolve = ops::resolve_with_previous(
         &mut registry,
         ws,
         &CliFeatures::new_all(true),
         HasDevUnits::Yes,
-        None,
+        previous_resolve,
         None,
         &[],
         true,
     )?;
     ops::write_pkg_lockfile(ws, &mut resolve)?;
+    print_lockfile_changes(ws.gctx(), previous_resolve, &resolve, &mut registry)?;
     Ok(())
 }
 
@@ -154,7 +155,7 @@ pub fn update_lockfile(ws: &Workspace<'_>, opts: &UpdateOptions<'_>) -> CargoRes
         true,
     )?;
 
-    print_lockfile_update(opts.gctx, &previous_resolve, &resolve, &mut registry)?;
+    print_lockfile_updates(opts.gctx, &previous_resolve, &resolve, &mut registry)?;
     if opts.dry_run {
         opts.gctx
             .shell()
@@ -165,30 +166,177 @@ pub fn update_lockfile(ws: &Workspace<'_>, opts: &UpdateOptions<'_>) -> CargoRes
     Ok(())
 }
 
-fn print_lockfile_update(
+pub fn print_lockfile_changes(
+    gctx: &GlobalContext,
+    previous_resolve: Option<&Resolve>,
+    resolve: &Resolve,
+    registry: &mut PackageRegistry<'_>,
+) -> CargoResult<()> {
+    if let Some(previous_resolve) = previous_resolve {
+        print_lockfile_sync(gctx, previous_resolve, resolve, registry)
+    } else {
+        print_lockfile_generation(gctx, resolve, registry)
+    }
+}
+
+fn print_lockfile_generation(
+    gctx: &GlobalContext,
+    resolve: &Resolve,
+    registry: &mut PackageRegistry<'_>,
+) -> CargoResult<()> {
+    let mut shell = gctx.shell();
+
+    let diff = PackageDiff::new(&resolve);
+    let num_pkgs: usize = diff.iter().map(|d| d.added.len()).sum();
+    if num_pkgs <= 1 {
+        // just ourself, nothing worth reporting
+        return Ok(());
+    }
+    shell.status("Locking", format!("{num_pkgs} packages"))?;
+
+    for diff in diff {
+        fn format_latest(version: semver::Version) -> String {
+            let warn = style::WARN;
+            format!(" {warn}(latest: v{version}){warn:#}")
+        }
+        let possibilities = if let Some(query) = diff.alternatives_query() {
+            loop {
+                match registry.query_vec(&query, QueryKind::Exact) {
+                    std::task::Poll::Ready(res) => {
+                        break res?;
+                    }
+                    std::task::Poll::Pending => registry.block_until_ready()?,
+                }
+            }
+        } else {
+            vec![]
+        };
+
+        for package in diff.added.iter() {
+            let latest = if !possibilities.is_empty() {
+                possibilities
+                    .iter()
+                    .map(|s| s.as_summary())
+                    .filter(|s| is_latest(s.version(), package.version()))
+                    .map(|s| s.version().clone())
+                    .max()
+                    .map(format_latest)
+            } else {
+                None
+            };
+
+            if let Some(latest) = latest {
+                shell.status_with_color("Adding", format!("{package}{latest}"), &style::NOTE)?;
+            }
+        }
+    }
+
+    Ok(())
+}
+
+fn print_lockfile_sync(
     gctx: &GlobalContext,
     previous_resolve: &Resolve,
     resolve: &Resolve,
     registry: &mut PackageRegistry<'_>,
 ) -> CargoResult<()> {
-    // Summarize what is changing for the user.
-    let print_change = |status: &str, msg: String, color: &Style| {
-        gctx.shell().status_with_color(status, msg, color)
-    };
+    let mut shell = gctx.shell();
+
+    let diff = PackageDiff::diff(&previous_resolve, &resolve);
+    let num_pkgs: usize = diff.iter().map(|d| d.added.len()).sum();
+    if num_pkgs == 0 {
+        return Ok(());
+    }
+    let plural = if num_pkgs == 1 { "" } else { "s" };
+    shell.status("Locking", format!("{num_pkgs} package{plural}"))?;
+
+    for diff in diff {
+        fn format_latest(version: semver::Version) -> String {
+            let warn = style::WARN;
+            format!(" {warn}(latest: v{version}){warn:#}")
+        }
+        let possibilities = if let Some(query) = diff.alternatives_query() {
+            loop {
+                match registry.query_vec(&query, QueryKind::Exact) {
+                    std::task::Poll::Ready(res) => {
+                        break res?;
+                    }
+                    std::task::Poll::Pending => registry.block_until_ready()?,
+                }
+            }
+        } else {
+            vec![]
+        };
+
+        if let Some((removed, added)) = diff.change() {
+            let latest = if !possibilities.is_empty() {
+                possibilities
+                    .iter()
+                    .map(|s| s.as_summary())
+                    .filter(|s| is_latest(s.version(), added.version()))
+                    .map(|s| s.version().clone())
+                    .max()
+                    .map(format_latest)
+            } else {
+                None
+            }
+            .unwrap_or_default();
+
+            let msg = if removed.source_id().is_git() {
+                format!(
+                    "{removed} -> #{}",
+                    &added.source_id().precise_git_fragment().unwrap()[..8],
+                )
+            } else {
+                format!("{removed} -> v{}{latest}", added.version())
+            };
+
+            // If versions differ only in build metadata, we call it an "update"
+            // regardless of whether the build metadata has gone up or down.
+            // This metadata is often stuff like git commit hashes, which are
+            // not meaningfully ordered.
+            if removed.version().cmp_precedence(added.version()) == Ordering::Greater {
+                shell.status_with_color("Downgrading", msg, &style::WARN)?;
+            } else {
+                shell.status_with_color("Updating", msg, &style::GOOD)?;
+            }
+        } else {
+            for package in diff.added.iter() {
+                let latest = if !possibilities.is_empty() {
+                    possibilities
+                        .iter()
+                        .map(|s| s.as_summary())
+                        .filter(|s| is_latest(s.version(), package.version()))
+                        .map(|s| s.version().clone())
+                        .max()
+                        .map(format_latest)
+                } else {
+                    None
+                }
+                .unwrap_or_default();
+
+                shell.status_with_color("Adding", format!("{package}{latest}"), &style::NOTE)?;
+            }
+        }
+    }
+
+    Ok(())
+}
+
+pub fn print_lockfile_updates(
+    gctx: &GlobalContext,
+    previous_resolve: &Resolve,
+    resolve: &Resolve,
+    registry: &mut PackageRegistry<'_>,
+) -> CargoResult<()> {
+    let mut shell = gctx.shell();
+
     let mut unchanged_behind = 0;
     for diff in PackageDiff::diff(&previous_resolve, &resolve) {
         fn format_latest(version: semver::Version) -> String {
             let warn = style::WARN;
             format!(" {warn}(latest: v{version}){warn:#}")
         }
-        fn is_latest(candidate: &semver::Version, current: &semver::Version) -> bool {
-            current < candidate
-                // Only match pre-release if major.minor.patch are the same
-                && (candidate.pre.is_empty()
-                    || (candidate.major == current.major
-                        && candidate.minor == current.minor
-                        && candidate.patch == current.patch))
-        }
         let possibilities = if let Some(query) = diff.alternatives_query() {
             loop {
                 match registry.query_vec(&query, QueryKind::Exact) {
@@ -230,13 +378,13 @@ fn print_lockfile_update(
             // This metadata is often stuff like git commit hashes, which are
             // not meaningfully ordered.
             if removed.version().cmp_precedence(added.version()) == Ordering::Greater {
-                print_change("Downgrading", msg, &style::WARN)?;
+                shell.status_with_color("Downgrading", msg, &style::WARN)?;
             } else {
-                print_change("Updating", msg, &style::GOOD)?;
+                shell.status_with_color("Updating", msg, &style::GOOD)?;
             }
         } else {
             for package in diff.removed.iter() {
-                print_change("Removing", format!("{package}"), &style::ERROR)?;
+                shell.status_with_color("Removing", format!("{package}"), &style::ERROR)?;
             }
             for package in diff.added.iter() {
                 let latest = if !possibilities.is_empty() {
@@ -252,7 +400,7 @@ fn print_lockfile_update(
                 }
                 .unwrap_or_default();
 
-                print_change("Adding", format!("{package}{latest}"), &style::NOTE)?;
+                shell.status_with_color("Adding", format!("{package}{latest}"), &style::NOTE)?;
             }
         }
         for package in &diff.unchanged {
@@ -270,8 +418,8 @@ fn print_lockfile_update(
 
             if let Some(latest) = latest {
                 unchanged_behind += 1;
-                if gctx.shell().verbosity() == Verbosity::Verbose {
-                    gctx.shell().status_with_color(
+                if shell.verbosity() == Verbosity::Verbose {
+                    shell.status_with_color(
                         "Unchanged",
                         format!("{package}{latest}"),
                         &anstyle::Style::new().bold(),
@@ -280,13 +428,13 @@ fn print_lockfile_update(
             }
         }
     }
-    if gctx.shell().verbosity() == Verbosity::Verbose {
-        gctx.shell().note(
+    if shell.verbosity() == Verbosity::Verbose {
+        shell.note(
             "to see how you depend on a package, run `cargo tree --invert --package <dep>@<ver>`",
         )?;
     } else {
         if 0 < unchanged_behind {
-            gctx.shell().note(format!(
+            shell.note(format!(
                 "pass `--verbose` to see {unchanged_behind} unchanged dependencies behind latest"
             ))?;
         }
@@ -295,6 +443,15 @@ fn print_lockfile_update(
     Ok(())
 }
 
+fn is_latest(candidate: &semver::Version, current: &semver::Version) -> bool {
+    current < candidate
+                // Only match pre-release if major.minor.patch are the same
+                && (candidate.pre.is_empty()
+                    || (candidate.major == current.major
+                        && candidate.minor == current.minor
+                        && candidate.patch == current.patch))
+}
+
 fn fill_with_deps<'a>(
     resolve: &'a Resolve,
     dep: PackageId,
@@ -319,11 +476,21 @@ pub struct PackageDiff {
 }
 
 impl PackageDiff {
-    pub fn diff(previous_resolve: &Resolve, resolve: &Resolve) -> Vec<Self> {
-        fn key(dep: PackageId) -> (&'static str, SourceId) {
-            (dep.name().as_str(), dep.source_id())
+    pub fn new(resolve: &Resolve) -> Vec<Self> {
+        let mut changes = BTreeMap::new();
+        let empty = Self::default();
+        for dep in resolve.iter() {
+            changes
+                .entry(Self::key(dep))
+                .or_insert_with(|| empty.clone())
+                .added
+                .push(dep);
         }
 
+        changes.into_iter().map(|(_, v)| v).collect()
+    }
+
+    pub fn diff(previous_resolve: &Resolve, resolve: &Resolve) -> Vec<Self> {
         fn vec_subset(a: &[PackageId], b: &[PackageId]) -> Vec<PackageId> {
             a.iter().filter(|a| !contains_id(b, a)).cloned().collect()
         }
@@ -364,14 +531,14 @@ impl PackageDiff {
         let empty = Self::default();
         for dep in previous_resolve.iter() {
             changes
-                .entry(key(dep))
+                .entry(Self::key(dep))
                 .or_insert_with(|| empty.clone())
                 .removed
                 .push(dep);
         }
         for dep in resolve.iter() {
             changes
-                .entry(key(dep))
+                .entry(Self::key(dep))
                 .or_insert_with(|| empty.clone())
                 .added
                 .push(dep);
@@ -397,6 +564,10 @@ impl PackageDiff {
         changes.into_iter().map(|(_, v)| v).collect()
     }
 
+    fn key(dep: PackageId) -> (&'static str, SourceId) {
+        (dep.name().as_str(), dep.source_id())
+    }
+
     /// Guess if a package upgraded/downgraded
     ///
     /// All `PackageDiff` knows is that entries were added/removed within [`Resolve`].