Add format option to cargo tree to print the package version constraint

- Add a new formatting option {c} to `cargo tree` that prints the resolved
version constraint of packages as specified in Cargo.toml.
- Add a unit test to verify that the version constraint is printed correctly.
- Update the `cargo tree` command documentation with the new option.

Author: devodev

src/cargo/ops/tree/format/mod.rs

@@ -2,6 +2,8 @@ use std::fmt;
 
 use anyhow::{Error, bail};
 
+use crate::ops::tree::graph::NodePackage;
+
 use self::parse::{Parser, RawChunk};
 use super::{Graph, Node, NodeId};
 
@@ -14,6 +16,7 @@ enum Chunk {
     Repository,
     Features,
     LibName,
+    Constraint,
 }
 
 pub struct Pattern(Vec<Chunk>);
@@ -30,6 +33,7 @@ impl Pattern {
                 RawChunk::Argument("r") => Chunk::Repository,
                 RawChunk::Argument("f") => Chunk::Features,
                 RawChunk::Argument("lib") => Chunk::LibName,
+                RawChunk::Argument("c") => Chunk::Constraint,
                 RawChunk::Argument(a) => {
                     bail!("unsupported pattern `{}`", a);
                 }
@@ -60,11 +64,12 @@ impl<'a> fmt::Display for Display<'a> {
     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         let node = self.graph.node(self.node_index);
         match node {
-            Node::Package {
+            Node::Package(NodePackage {
                 package_id,
                 features,
+                version_req,
                 ..
-            } => {
+            }) => {
                 let package = self.graph.package_for_id(*package_id);
                 for chunk in &self.pattern.0 {
                     match chunk {
@@ -111,13 +116,16 @@ impl<'a> fmt::Display for Display<'a> {
                                 write!(fmt, "{}", target.crate_name())?;
                             }
                         }
+                        Chunk::Constraint => {
+                            write!(fmt, "{}", version_req)?;
+                        }
                     }
                 }
             }
             Node::Feature { name, node_index } => {
                 let for_node = self.graph.node(*node_index);
                 match for_node {
-                    Node::Package { package_id, .. } => {
+                    Node::Package(NodePackage { package_id, .. }) => {
                         write!(fmt, "{} feature \"{}\"", package_id.name(), name)?;
                         if self.graph.is_cli_feature(self.node_index) {
                             write!(fmt, " (command-line)")?;

src/cargo/ops/tree/graph.rs

@@ -6,8 +6,9 @@ use crate::core::dependency::DepKind;
 use crate::core::resolver::Resolve;
 use crate::core::resolver::features::{CliFeatures, FeaturesFor, ResolvedFeatures};
 use crate::core::{FeatureMap, FeatureValue, Package, PackageId, PackageIdSpec, Workspace};
-use crate::util::CargoResult;
 use crate::util::interning::{INTERNED_DEFAULT, InternedString};
+use crate::util::{CargoResult, OptVersionReq};
+use std::cmp::Ordering;
 use std::collections::{HashMap, HashSet};
 
 #[derive(Debug, Copy, Clone)]
@@ -49,14 +50,34 @@ impl std::hash::Hash for NodeId {
     }
 }
 
+#[derive(Debug, Clone, Eq, PartialEq, Hash)]
+pub struct NodePackage {
+    pub package_id: PackageId,
+    /// Features that are enabled on this package.
+    pub features: Vec<InternedString>,
+    pub kind: CompileKind,
+    pub version_req: OptVersionReq,
+}
+
+impl PartialOrd for NodePackage {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for NodePackage {
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.package_id
+            .cmp(&other.package_id)
+            .then_with(|| self.features.cmp(&other.features))
+            .then_with(|| self.kind.cmp(&other.kind))
+        // version_req is not orderable
+    }
+}
+
 #[derive(Debug, Clone, Eq, PartialEq, Hash, Ord, PartialOrd)]
 pub enum Node {
-    Package {
-        package_id: PackageId,
-        /// Features that are enabled on this package.
-        features: Vec<InternedString>,
-        kind: CompileKind,
-    },
+    Package(NodePackage),
     Feature {
         /// Index of the package node this feature is for.
         node_index: NodeId,
@@ -68,7 +89,7 @@ pub enum Node {
 impl Node {
     fn name(&self) -> InternedString {
         match self {
-            Self::Package { package_id, .. } => package_id.name(),
+            Self::Package(NodePackage { package_id, .. }) => package_id.name(),
             Self::Feature { name, .. } => *name,
         }
     }
@@ -218,7 +239,7 @@ impl<'a> Graph<'a> {
             .iter()
             .enumerate()
             .filter(|(_i, node)| match node {
-                Node::Package { package_id, .. } => package_ids.contains(package_id),
+                Node::Package(NodePackage { package_id, .. }) => package_ids.contains(package_id),
                 _ => false,
             })
             .map(|(i, node)| (node, NodeId::new(i, node.name())))
@@ -235,7 +256,7 @@ impl<'a> Graph<'a> {
 
     fn package_id_for_index(&self, index: NodeId) -> PackageId {
         match self.node(index) {
-            Node::Package { package_id, .. } => *package_id,
+            Node::Package(NodePackage { package_id, .. }) => *package_id,
             Node::Feature { .. } => panic!("unexpected feature node"),
         }
     }
@@ -314,7 +335,7 @@ impl<'a> Graph<'a> {
         // Collect a map of package name to Vec<(&Node, NodeId)>.
         let mut packages = HashMap::new();
         for (i, node) in self.nodes.iter().enumerate() {
-            if let Node::Package { package_id, .. } = node {
+            if let Node::Package(NodePackage { package_id, .. }) = node {
                 packages
                     .entry(package_id.name())
                     .or_insert_with(Vec::new)
@@ -329,17 +350,19 @@ impl<'a> Graph<'a> {
                     .into_iter()
                     .map(|(node, _)| {
                         match node {
-                            Node::Package {
+                            Node::Package(NodePackage {
                                 package_id,
                                 features,
+                                version_req,
                                 ..
-                            } => {
+                            }) => {
                                 // Do not treat duplicates on the host or target as duplicates.
-                                Node::Package {
+                                Node::Package(NodePackage {
                                     package_id: package_id.clone(),
                                     features: features.clone(),
                                     kind: CompileKind::Host,
-                                }
+                                    version_req: version_req.clone(),
+                                })
                             }
                             _ => unreachable!(),
                         }
@@ -376,12 +399,14 @@ pub fn build<'a>(
         let member_id = member.package_id();
         let features_for = FeaturesFor::from_for_host(member.proc_macro());
         for kind in requested_kinds {
+            let version_req = OptVersionReq::Any;
             let member_index = add_pkg(
                 &mut graph,
                 resolve,
                 resolved_features,
                 member_id,
                 features_for,
+                version_req,
                 target_data,
                 *kind,
                 opts,
@@ -409,6 +434,7 @@ fn add_pkg(
     resolved_features: &ResolvedFeatures,
     package_id: PackageId,
     features_for: FeaturesFor,
+    version_req: OptVersionReq,
     target_data: &RustcTargetData<'_>,
     requested_kind: CompileKind,
     opts: &TreeOptions,
@@ -419,11 +445,12 @@ fn add_pkg(
         FeaturesFor::ArtifactDep(target) => CompileKind::Target(target),
         FeaturesFor::NormalOrDev => requested_kind,
     };
-    let node = Node::Package {
+    let node = Node::Package(NodePackage {
         package_id,
         features: node_features,
         kind: node_kind,
-    };
+        version_req: version_req,
+    });
     if let Some(idx) = graph.index.get(&node) {
         return *idx;
     }
@@ -513,12 +540,14 @@ fn add_pkg(
                     }
                 }
             };
+            let dep_version_req = dep.version_req().clone();
             let dep_index = add_pkg(
                 graph,
                 resolve,
                 resolved_features,
                 dep_id,
                 dep_features_for,
+                dep_version_req,
                 target_data,
                 requested_kind,
                 opts,

src/cargo/ops/tree/mod.rs

@@ -6,6 +6,7 @@ use crate::core::dependency::DepKind;
 use crate::core::resolver::{ForceAllTargets, HasDevUnits, features::CliFeatures};
 use crate::core::{Package, PackageId, PackageIdSpec, PackageIdSpecQuery, Workspace};
 use crate::ops::resolve::SpecsAndResolvedFeatures;
+use crate::ops::tree::graph::NodePackage;
 use crate::ops::{self, Packages};
 use crate::util::CargoResult;
 use crate::util::style;
@@ -442,7 +443,7 @@ fn print_dependencies<'a>(
         .filter(|dep| {
             // Filter out packages to prune.
             match graph.node(dep.node()) {
-                Node::Package { package_id, .. } => {
+                Node::Package(NodePackage { package_id, .. }) => {
                     if filter_non_workspace_member && !ws.is_member_id(*package_id) {
                         return false;
                     }

src/doc/man/cargo-tree.md

@@ -167,6 +167,7 @@ strings will be replaced with the corresponding value:
 - `{r}` --- The package repository URL.
 - `{f}` --- Comma-separated list of package features that are enabled.
 - `{lib}` --- The name, as used in a `use` statement, of the package's library.
+- `{c}` --- The version constraint resolved for the package.
 {{/option}}
 
 {{#option "`--prefix` _prefix_" }}

src/doc/man/generated_txt/cargo-tree.txt

@@ -166,6 +166,8 @@ OPTIONS
            o  {lib} — The name, as used in a use statement, of the
               package’s library.
 
+           o  {c} — The version constraint resolved for the package.
+
        --prefix prefix
            Sets how each line is displayed. The prefix value can be one of:
 

src/doc/src/commands/cargo-tree.md

@@ -170,6 +170,7 @@ strings will be replaced with the corresponding value:</p>
 <li><code>{r}</code> — The package repository URL.</li>
 <li><code>{f}</code> — Comma-separated list of package features that are enabled.</li>
 <li><code>{lib}</code> — The name, as used in a <code>use</code> statement, of the package’s library.</li>
+<li><code>{c}</code> — The version constraint resolved for the package.</li>
 </ul>
 </dd>
 

src/etc/man/cargo-tree.1

@@ -208,6 +208,10 @@ strings will be replaced with the corresponding value:
 .RS 4
 \h'-04'\(bu\h'+03'\fB{lib}\fR \[em] The name, as used in a \fBuse\fR statement, of the package\[cq]s library.
 .RE
+.sp
+.RS 4
+\h'-04'\(bu\h'+03'\fB{c}\fR \[em] The version constraint resolved for the package.
+.RE
 .RE
 .sp
 \fB\-\-prefix\fR \fIprefix\fR