make resolve_features a stand alone function

Author: Eh2406

src/cargo/core/resolver/context.rs

@@ -8,13 +8,14 @@ use failure::{bail, ensure};
 use log::debug;
 
 use crate::core::interning::InternedString;
-use crate::core::{Dependency, FeatureValue, PackageId, SourceId, Summary};
+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, ConflictReason, DepInfo, Method};
+use super::types::{ConflictMap, DepInfo, Method};
 
 pub use super::encode::{EncodableDependency, EncodablePackageId, EncodableResolve};
 pub use super::encode::{Metadata, WorkspaceResolve};
@@ -150,15 +151,25 @@ impl Context {
 
     pub fn build_deps(
         &mut self,
-        registry: &mut RegistryQueryer<'_>,
+        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 deps = self.resolve_features(parent, candidate, method)?;
+        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::new(HashSet::with_capacity(used_features.len()))),
+            )
+            .extend(used_features);
+        }
 
         // Next, transform all dependencies into a list of possible candidates
         // which can satisfy that dependency.
@@ -212,110 +223,6 @@ impl Context {
         Some(max)
     }
 
-    /// Returns all dependencies and the features we want from them.
-    pub fn resolve_features<'b>(
-        &mut self,
-        parent: Option<PackageId>,
-        s: &'b Summary,
-        method: &'b Method<'_>,
-    ) -> ActivateResult<Vec<(Dependency, Vec<InternedString>)>> {
-        let dev_deps = match *method {
-            Method::Everything => true,
-            Method::Required { dev_deps, .. } => dev_deps,
-        };
-
-        // First, filter by dev-dependencies.
-        let deps = s.dependencies();
-        let deps = deps.iter().filter(|d| d.is_transitive() || dev_deps);
-
-        let reqs = build_requirements(s, method)?;
-        let mut ret = Vec::new();
-        let mut used_features = HashSet::new();
-        let default_dep = (false, Vec::new());
-
-        // Next, collect all actually enabled dependencies and their features.
-        for dep in deps {
-            // Skip optional dependencies, but not those enabled through a
-            // feature
-            if dep.is_optional() && !reqs.deps.contains_key(&dep.name_in_toml()) {
-                continue;
-            }
-            // So we want this dependency. Move the features we want from
-            // `feature_deps` to `ret` and register ourselves as using this
-            // name.
-            let base = reqs.deps.get(&dep.name_in_toml()).unwrap_or(&default_dep);
-            used_features.insert(dep.name_in_toml());
-            let always_required = !dep.is_optional()
-                && !s
-                    .dependencies()
-                    .iter()
-                    .any(|d| d.is_optional() && d.name_in_toml() == dep.name_in_toml());
-            if always_required && base.0 {
-                return Err(match parent {
-                    None => failure::format_err!(
-                        "Package `{}` does not have feature `{}`. It has a required dependency \
-                         with that name, but only optional dependencies can be used as features.",
-                        s.package_id(),
-                        dep.name_in_toml()
-                    )
-                    .into(),
-                    Some(p) => (
-                        p.package_id(),
-                        ConflictReason::RequiredDependencyAsFeatures(dep.name_in_toml()),
-                    )
-                        .into(),
-                });
-            }
-            let mut base = base.1.clone();
-            base.extend(dep.features().iter());
-            for feature in base.iter() {
-                if feature.contains('/') {
-                    return Err(failure::format_err!(
-                        "feature names may not contain slashes: `{}`",
-                        feature
-                    )
-                    .into());
-                }
-            }
-            ret.push((dep.clone(), base));
-        }
-
-        // Any entries in `reqs.dep` which weren't used are bugs in that the
-        // package does not actually have those dependencies. We classified
-        // them as dependencies in the first place because there is no such
-        // feature, either.
-        let remaining = reqs
-            .deps
-            .keys()
-            .cloned()
-            .filter(|s| !used_features.contains(s))
-            .collect::<Vec<_>>();
-        if !remaining.is_empty() {
-            let features = remaining.join(", ");
-            return Err(match parent {
-                None => failure::format_err!(
-                    "Package `{}` does not have these features: `{}`",
-                    s.package_id(),
-                    features
-                )
-                .into(),
-                Some(p) => (p, ConflictReason::MissingFeatures(features)).into(),
-            });
-        }
-
-        // Record what list of features is active for this package.
-        if !reqs.used.is_empty() {
-            Rc::make_mut(
-                self.resolve_features
-                    .entry(s.package_id())
-                    .or_insert_with(|| Rc::new(HashSet::with_capacity(reqs.used.len()))),
-            )
-            .extend(reqs.used);
-        }
-
-        Ok(ret)
-    }
-
     pub fn resolve_replacements(
         &self,
         registry: &RegistryQueryer<'_>,
@@ -342,136 +249,3 @@ impl Context {
         graph
     }
 }
-
-/// Takes requested features for a single package from the input `Method` and
-/// recurses to find all requested features, dependencies and requested
-/// dependency features in a `Requirements` object, returning it to the resolver.
-fn build_requirements<'a, 'b: 'a>(
-    s: &'a Summary,
-    method: &'b Method<'_>,
-) -> CargoResult<Requirements<'a>> {
-    let mut reqs = Requirements::new(s);
-
-    match *method {
-        Method::Everything
-        | Method::Required {
-            all_features: true, ..
-        } => {
-            for key in s.features().keys() {
-                reqs.require_feature(*key)?;
-            }
-            for dep in s.dependencies().iter().filter(|d| d.is_optional()) {
-                reqs.require_dependency(dep.name_in_toml());
-            }
-        }
-        Method::Required {
-            all_features: false,
-            features: requested,
-            ..
-        } => {
-            for &f in requested.iter() {
-                reqs.require_value(&FeatureValue::new(f, s))?;
-            }
-        }
-    }
-    match *method {
-        Method::Everything
-        | Method::Required {
-            uses_default_features: true,
-            ..
-        } => {
-            if s.features().contains_key("default") {
-                reqs.require_feature(InternedString::new("default"))?;
-            }
-        }
-        Method::Required {
-            uses_default_features: false,
-            ..
-        } => {}
-    }
-    Ok(reqs)
-}
-
-struct Requirements<'a> {
-    summary: &'a Summary,
-    // The deps map is a mapping of package name to list of features enabled.
-    // Each package should be enabled, and each package should have the
-    // specified set of features enabled. The boolean indicates whether this
-    // package was specifically requested (rather than just requesting features
-    // *within* this package).
-    deps: HashMap<InternedString, (bool, Vec<InternedString>)>,
-    // The used features set is the set of features which this local package had
-    // enabled, which is later used when compiling to instruct the code what
-    // features were enabled.
-    used: HashSet<InternedString>,
-    visited: HashSet<InternedString>,
-}
-
-impl Requirements<'_> {
-    fn new(summary: &Summary) -> Requirements<'_> {
-        Requirements {
-            summary,
-            deps: HashMap::new(),
-            used: HashSet::new(),
-            visited: HashSet::new(),
-        }
-    }
-
-    fn require_crate_feature(&mut self, package: InternedString, feat: InternedString) {
-        self.used.insert(package);
-        self.deps
-            .entry(package)
-            .or_insert((false, Vec::new()))
-            .1
-            .push(feat);
-    }
-
-    fn seen(&mut self, feat: InternedString) -> bool {
-        if self.visited.insert(feat) {
-            self.used.insert(feat);
-            false
-        } else {
-            true
-        }
-    }
-
-    fn require_dependency(&mut self, pkg: InternedString) {
-        if self.seen(pkg) {
-            return;
-        }
-        self.deps.entry(pkg).or_insert((false, Vec::new())).0 = true;
-    }
-
-    fn require_feature(&mut self, feat: InternedString) -> CargoResult<()> {
-        if feat.is_empty() || self.seen(feat) {
-            return Ok(());
-        }
-        for fv in self
-            .summary
-            .features()
-            .get(feat.as_str())
-            .expect("must be a valid feature")
-        {
-            match *fv {
-                FeatureValue::Feature(ref dep_feat) if **dep_feat == *feat => failure::bail!(
-                    "cyclic feature dependency: feature `{}` depends on itself",
-                    feat
-                ),
-                _ => {}
-            }
-            self.require_value(fv)?;
-        }
-        Ok(())
-    }
-
-    fn require_value(&mut self, fv: &FeatureValue) -> CargoResult<()> {
-        match fv {
-            FeatureValue::Feature(feat) => self.require_feature(*feat)?,
-            FeatureValue::Crate(dep) => self.require_dependency(*dep),
-            FeatureValue::CrateFeature(dep, dep_feat) => {
-                self.require_crate_feature(*dep, *dep_feat)
-            }
-        };
-        Ok(())
-    }
-}