make build_deps a stand alone function

Author: Eh2406

src/cargo/core/resolver/context.rs

@@ -12,10 +12,8 @@ use crate::core::{Dependency, PackageId, SourceId, Summary};
 use crate::util::CargoResult;
 use crate::util::Graph;
 
-use super::dep_cache;
 use super::dep_cache::RegistryQueryer;
-use super::errors::ActivateResult;
-use super::types::{ConflictMap, DepInfo, Method};
+use super::types::{ConflictMap, Method};
 
 pub use super::encode::{EncodableDependency, EncodablePackageId, EncodableResolve};
 pub use super::encode::{Metadata, WorkspaceResolve};
@@ -150,47 +148,6 @@ impl Context {
         })
     }
 
-    pub fn build_deps(
-        &mut self,
-        registry: &mut dep_cache::RegistryQueryer<'_>,
-        parent: Option<PackageId>,
-        candidate: &Summary,
-        method: &Method,
-    ) -> ActivateResult<Vec<DepInfo>> {
-        // First, figure out our set of dependencies based on the requested set
-        // of features. This also calculates what features we're going to enable
-        // for our own dependencies.
-        let (used_features, deps) = dep_cache::resolve_features(parent, candidate, method)?;
-
-        // Record what list of features is active for this package.
-        if !used_features.is_empty() {
-            Rc::make_mut(
-                self.resolve_features
-                    .entry(candidate.package_id())
-                    .or_insert_with(Rc::default),
-            )
-            .extend(used_features);
-        }
-
-        // Next, transform all dependencies into a list of possible candidates
-        // which can satisfy that dependency.
-        let mut deps = deps
-            .into_iter()
-            .map(|(dep, features)| {
-                let candidates = registry.query(&dep)?;
-                Ok((dep, candidates, Rc::new(features)))
-            })
-            .collect::<CargoResult<Vec<DepInfo>>>()?;
-
-        // Attempt to resolve dependencies with fewer candidates before trying
-        // dependencies with more candidates. This way if the dependency with
-        // only one candidate can't be resolved we don't have to do a bunch of
-        // work before we figure that out.
-        deps.sort_by_key(|&(_, ref a, _)| a.len());
-
-        Ok(deps)
-    }
-
     /// Returns the `ContextAge` of this `Context`.
     /// For now we use (len of activations) as the age.
     /// See the `ContextAge` docs for more details.

src/cargo/core/resolver/dep_cache.rs

@@ -8,7 +8,7 @@ use crate::core::interning::InternedString;
 use crate::core::{Dependency, FeatureValue, PackageId, PackageIdSpec, Registry, Summary};
 use crate::util::errors::CargoResult;
 
-use crate::core::resolver::types::{Candidate, ConflictReason};
+use crate::core::resolver::types::{Candidate, ConflictReason, DepInfo};
 use crate::core::resolver::{ActivateResult, Method};
 
 pub struct RegistryQueryer<'a> {
@@ -177,6 +177,36 @@ impl<'a> RegistryQueryer<'a> {
     }
 }
 
+pub fn build_deps(
+    registry: &mut RegistryQueryer<'_>,
+    parent: Option<PackageId>,
+    candidate: &Summary,
+    method: &Method,
+) -> ActivateResult<(HashSet<InternedString>, Vec<DepInfo>)> {
+    // First, figure out our set of dependencies based on the requested set
+    // of features. This also calculates what features we're going to enable
+    // for our own dependencies.
+    let (used_features, deps) = resolve_features(parent, candidate, method)?;
+
+    // Next, transform all dependencies into a list of possible candidates
+    // which can satisfy that dependency.
+    let mut deps = deps
+        .into_iter()
+        .map(|(dep, features)| {
+            let candidates = registry.query(&dep)?;
+            Ok((dep, candidates, Rc::new(features)))
+        })
+        .collect::<CargoResult<Vec<DepInfo>>>()?;
+
+    // Attempt to resolve dependencies with fewer candidates before trying
+    // dependencies with more candidates. This way if the dependency with
+    // only one candidate can't be resolved we don't have to do a bunch of
+    // work before we figure that out.
+    deps.sort_by_key(|&(_, ref a, _)| a.len());
+
+    Ok((used_features, deps))
+}
+
 /// Returns all dependencies and the features we want from them.
 pub fn resolve_features<'b>(
     parent: Option<PackageId>,

src/cargo/core/resolver/mod.rs

@@ -682,12 +682,23 @@ fn activate(
     };
 
     let now = Instant::now();
-    let deps = cx.build_deps(
+    let (used_features, deps) = dep_cache::build_deps(
         registry,
         parent.map(|p| p.0.package_id()),
         &candidate,
         method,
     )?;
+
+    // Record what list of features is active for this package.
+    if !used_features.is_empty() {
+        Rc::make_mut(
+            cx.resolve_features
+                .entry(candidate.package_id())
+                .or_insert_with(Rc::default),
+        )
+        .extend(used_features);
+    }
+
     let frame = DepsFrame {
         parent: candidate,
         just_for_error_messages: false,

src/cargo/core/resolver/types.rs

@@ -218,9 +218,9 @@ impl RemainingDeps {
     }
 }
 
-// Information about the dependencies for a crate, a tuple of:
-//
-// (dependency info, candidates, features activated)
+/// Information about the dependencies for a crate, a tuple of:
+///
+/// (dependency info, candidates, features activated)
 pub type DepInfo = (Dependency, Rc<Vec<Candidate>>, Rc<BTreeSet<InternedString>>);
 
 /// All possible reasons that a package might fail to activate.