Add dep requirement info for dep-chain display

Author: weihanglo

src/cargo/core/resolver/dep_cache.rs

@@ -10,7 +10,7 @@
 //! This module impl that cache in all the gory details
 
 use crate::core::resolver::context::Context;
-use crate::core::resolver::errors::describe_path;
+use crate::core::resolver::errors::describe_path_in_context;
 use crate::core::resolver::types::{ConflictReason, DepInfo, FeaturesSet};
 use crate::core::resolver::{
     ActivateError, ActivateResult, CliFeatures, RequestedFeatures, ResolveOpts, VersionOrdering,
@@ -216,7 +216,7 @@ impl<'a> RegistryQueryer<'a> {
                     format!(
                         "failed to get `{}` as a dependency of {}",
                         dep.package_name(),
-                        describe_path(&cx.parents.path_to_bottom(&candidate.package_id())),
+                        describe_path_in_context(cx, &candidate.package_id()),
                     )
                 })?;
                 Ok((dep, candidates, features))

src/cargo/core/resolver/errors.rs

@@ -82,6 +82,7 @@ pub(super) fn activation_error(
             cx.parents
                 .path_to_bottom(&parent.package_id())
                 .into_iter()
+                .map(|(node, _)| node)
                 .cloned()
                 .collect(),
         )
@@ -90,9 +91,7 @@ pub(super) fn activation_error(
     if !candidates.is_empty() {
         let mut msg = format!("failed to select a version for `{}`.", dep.package_name());
         msg.push_str("\n    ... required by ");
-        msg.push_str(&describe_path(
-            &cx.parents.path_to_bottom(&parent.package_id()),
-        ));
+        msg.push_str(&describe_path_in_context(cx, &parent.package_id()));
 
         msg.push_str("\nversions that meet the requirements `");
         msg.push_str(&dep.version_req().to_string());
@@ -128,7 +127,7 @@ pub(super) fn activation_error(
                     msg.push_str("`, but it conflicts with a previous package which links to `");
                     msg.push_str(link);
                     msg.push_str("` as well:\n");
-                    msg.push_str(&describe_path(&cx.parents.path_to_bottom(p)));
+                    msg.push_str(&describe_path_in_context(cx, p));
                     msg.push_str("\nOnly one package in the dependency graph may specify the same links value. This helps ensure that only one copy of a native library is linked in the final binary. ");
                     msg.push_str("Try to adjust your dependencies so that only one package uses the links ='");
                     msg.push_str(&*dep.package_name());
@@ -197,7 +196,7 @@ pub(super) fn activation_error(
             for (p, r) in &conflicting_activations {
                 if let ConflictReason::Semver = r {
                     msg.push_str("\n\n  previously selected ");
-                    msg.push_str(&describe_path(&cx.parents.path_to_bottom(p)));
+                    msg.push_str(&describe_path_in_context(cx, p));
                 }
             }
         }
@@ -250,9 +249,7 @@ pub(super) fn activation_error(
                 registry.describe_source(dep.source_id()),
             );
             msg.push_str("required by ");
-            msg.push_str(&describe_path(
-                &cx.parents.path_to_bottom(&parent.package_id()),
-            ));
+            msg.push_str(&describe_path_in_context(cx, &parent.package_id()));
 
             // If we have a path dependency with a locked version, then this may
             // indicate that we updated a sub-package and forgot to run `cargo
@@ -330,9 +327,7 @@ pub(super) fn activation_error(
             }
             msg.push_str(&format!("location searched: {}\n", dep.source_id()));
             msg.push_str("required by ");
-            msg.push_str(&describe_path(
-                &cx.parents.path_to_bottom(&parent.package_id()),
-            ));
+            msg.push_str(&describe_path_in_context(cx, &parent.package_id()));
 
             msg
         };
@@ -351,12 +346,57 @@ pub(super) fn activation_error(
     to_resolve_err(anyhow::format_err!("{}", msg))
 }
 
+/// Returns String representation of dependency chain for a particular `pkgid`
+/// within given context.
+pub(super) fn describe_path_in_context(cx: &Context, id: &PackageId) -> String {
+    let iter = cx
+        .parents
+        .path_to_bottom(id)
+        .into_iter()
+        .map(|(p, d)| (p, d.and_then(|d| d.iter().next())));
+    describe_path(iter)
+}
+
 /// Returns String representation of dependency chain for a particular `pkgid`.
-pub(super) fn describe_path(path: &[&PackageId]) -> String {
+///
+/// Note that all elements of `path` iterator should have `Some` dependency
+/// except the first one. It would look like:
+///
+/// (pkg0, None)
+/// -> (pkg1, dep from pkg1 satisfied by pkg0)
+/// -> (pkg2, dep from pkg2 satisfied by pkg1)
+/// -> ...
+pub(super) fn describe_path<'a>(
+    mut path: impl Iterator<Item = (&'a PackageId, Option<&'a Dependency>)>,
+) -> String {
     use std::fmt::Write;
-    let mut dep_path_desc = format!("package `{}`", path[0]);
-    for dep in path[1..].iter() {
-        write!(dep_path_desc, "\n    ... which is depended on by `{}`", dep).unwrap();
+
+    if let Some(p) = path.next() {
+        let mut dep_path_desc = format!("package `{}`", p.0);
+        for (pkg, dep) in path {
+            let dep = dep.unwrap();
+            let source_kind = if dep.source_id().is_path() {
+                "path "
+            } else if dep.source_id().is_git() {
+                "git "
+            } else {
+                ""
+            };
+            let requirement = if source_kind.is_empty() {
+                format!("{} = \"{}\"", dep.name_in_toml(), dep.version_req())
+            } else {
+                dep.name_in_toml().to_string()
+            };
+            write!(
+                dep_path_desc,
+                "\n    ... which satisfies {}dependency `{}` of package `{}`",
+                source_kind, requirement, pkg
+            )
+            .unwrap();
+        }
+
+        return dep_path_desc;
     }
-    dep_path_desc
+
+    String::new()
 }

src/cargo/util/graph.rs

@@ -89,17 +89,22 @@ impl<N: Eq + Ord + Clone, E: Default + Clone> Graph<N, E> {
 
     /// Resolves one of the paths from the given dependent package down to
     /// a leaf.
-    pub fn path_to_bottom<'a>(&'a self, mut pkg: &'a N) -> Vec<&'a N> {
-        let mut result = vec![pkg];
+    ///
+    /// Each element contains a node along with an edge except the first one.
+    /// The representation would look like:
+    ///
+    /// (Node0,) -> (Node1, Edge01) -> (Node2, Edge12)...
+    pub fn path_to_bottom<'a>(&'a self, mut pkg: &'a N) -> Vec<(&'a N, Option<&'a E>)> {
+        let mut result = vec![(pkg, None)];
         while let Some(p) = self.nodes.get(pkg).and_then(|p| {
             p.iter()
                 // Note that we can have "cycles" introduced through dev-dependency
                 // edges, so make sure we don't loop infinitely.
-                .find(|(node, _)| !result.contains(node))
-                .map(|(p, _)| p)
+                .find(|&(node, _)| result.iter().all(|p| p.0 != node))
+                .map(|(node, edge)| (node, Some(edge)))
         }) {
             result.push(p);
-            pkg = p;
+            pkg = p.0;
         }
         result
     }