Change for_build_dep from a bool to enum FeaturesFor for clarity.

Author: ehuss

src/cargo/core/compiler/standard_lib.rs

@@ -2,7 +2,7 @@
 
 use crate::core::compiler::{BuildContext, CompileKind, CompileMode, RustcTargetData, Unit};
 use crate::core::profiles::UnitFor;
-use crate::core::resolver::features::ResolvedFeatures;
+use crate::core::resolver::features::{FeaturesFor, ResolvedFeatures};
 use crate::core::resolver::{HasDevUnits, ResolveOpts};
 use crate::core::{Dependency, PackageId, PackageSet, Resolve, SourceId, Workspace};
 use crate::ops::{self, Packages};
@@ -154,7 +154,8 @@ pub fn generate_std_roots<'a>(
                 unit_for,
                 mode,
             );
-            let features = std_features.activated_features(pkg.package_id(), false);
+            let features =
+                std_features.activated_features(pkg.package_id(), FeaturesFor::NormalOrDev);
             Ok(bcx.units.intern(
                 pkg, lib, profile, kind, mode, features, /*is_std*/ true,
             ))

src/cargo/core/compiler/unit_dependencies.rs

@@ -20,7 +20,7 @@ use crate::core::compiler::{BuildContext, CompileKind, CompileMode};
 use crate::core::dependency::DepKind;
 use crate::core::package::Downloads;
 use crate::core::profiles::{Profile, UnitFor};
-use crate::core::resolver::features::ResolvedFeatures;
+use crate::core::resolver::features::{FeaturesFor, ResolvedFeatures};
 use crate::core::resolver::Resolve;
 use crate::core::{InternedString, Package, PackageId, Target};
 use crate::CargoResult;
@@ -586,7 +586,11 @@ fn new_unit_dep_with_profile<'a>(
     let public = state
         .resolve()
         .is_public_dep(parent.pkg.package_id(), pkg.package_id());
-    let features = state.activated_features(pkg.package_id(), unit_for.is_for_build_dep());
+    let features_for = match unit_for.is_for_build_dep() {
+        true => FeaturesFor::BuildDep,
+        false => FeaturesFor::NormalOrDev,
+    };
+    let features = state.activated_features(pkg.package_id(), features_for);
     let unit = state
         .bcx
         .units
@@ -691,13 +695,17 @@ impl<'a, 'cfg> State<'a, 'cfg> {
         }
     }
 
-    fn activated_features(&self, pkg_id: PackageId, for_build_dep: bool) -> Vec<InternedString> {
+    fn activated_features(
+        &self,
+        pkg_id: PackageId,
+        features_for: FeaturesFor,
+    ) -> Vec<InternedString> {
         let features = if self.is_std {
             self.std_features.unwrap()
         } else {
             self.usr_features
         };
-        features.activated_features(pkg_id, for_build_dep)
+        features.activated_features(pkg_id, features_for)
     }
 
     fn get(&mut self, id: PackageId) -> CargoResult<Option<&'a Package>> {

src/cargo/core/resolver/features.rs

@@ -68,6 +68,13 @@ pub enum HasDevUnits {
     No,
 }
 
+/// Flag to indicate if features are requested for a build dependency or not.
+#[derive(PartialEq)]
+pub enum FeaturesFor {
+    NormalOrDev,
+    BuildDep,
+}
+
 impl FeatureOpts {
     fn new(config: &Config, has_dev_units: HasDevUnits) -> CargoResult<FeatureOpts> {
         let mut opts = FeatureOpts::default();
@@ -156,8 +163,12 @@ impl RequestedFeatures {
 
 impl ResolvedFeatures {
     /// Returns the list of features that are enabled for the given package.
-    pub fn activated_features(&self, pkg_id: PackageId, is_build: bool) -> Vec<InternedString> {
-        self.activated_features_int(pkg_id, is_build, true)
+    pub fn activated_features(
+        &self,
+        pkg_id: PackageId,
+        features_for: FeaturesFor,
+    ) -> Vec<InternedString> {
+        self.activated_features_int(pkg_id, features_for, true)
     }
 
     /// Variant of `activated_features` that returns an empty Vec if this is
@@ -166,21 +177,21 @@ impl ResolvedFeatures {
     pub fn activated_features_unverified(
         &self,
         pkg_id: PackageId,
-        is_build: bool,
+        features_for: FeaturesFor,
     ) -> Vec<InternedString> {
-        self.activated_features_int(pkg_id, is_build, false)
+        self.activated_features_int(pkg_id, features_for, false)
     }
 
     fn activated_features_int(
         &self,
         pkg_id: PackageId,
-        is_build: bool,
+        features_for: FeaturesFor,
         verify: bool,
     ) -> Vec<InternedString> {
         if let Some(legacy) = &self.legacy {
             legacy.get(&pkg_id).map_or_else(Vec::new, |v| v.clone())
         } else {
-            let is_build = self.opts.decouple_build_deps && is_build;
+            let is_build = self.opts.decouple_build_deps && features_for == FeaturesFor::BuildDep;
             if let Some(fs) = self.activated_features.get(&(pkg_id, is_build)) {
                 fs.iter().cloned().collect()
             } else if verify {

src/cargo/ops/cargo_clean.rs

@@ -7,7 +7,9 @@ use crate::core::compiler::unit_dependencies;
 use crate::core::compiler::{BuildConfig, BuildContext, CompileKind, CompileMode, Context};
 use crate::core::compiler::{RustcTargetData, UnitInterner};
 use crate::core::profiles::{Profiles, UnitFor};
-use crate::core::resolver::features::{FeatureResolver, HasDevUnits, RequestedFeatures};
+use crate::core::resolver::features::{
+    FeatureResolver, FeaturesFor, HasDevUnits, RequestedFeatures,
+};
 use crate::core::{PackageIdSpec, Workspace};
 use crate::ops;
 use crate::util::errors::{CargoResult, CargoResultExt};
@@ -118,10 +120,12 @@ pub fn clean(ws: &Workspace<'_>, opts: &CleanOptions<'_>) -> CargoResult<()> {
                         };
                         // Use unverified here since this is being more
                         // exhaustive than what is actually needed.
-                        let features = features.activated_features_unverified(
-                            pkg.package_id(),
-                            unit_for.is_for_build_dep(),
-                        );
+                        let features_for = match unit_for.is_for_build_dep() {
+                            true => FeaturesFor::BuildDep,
+                            false => FeaturesFor::NormalOrDev,
+                        };
+                        let features =
+                            features.activated_features_unverified(pkg.package_id(), features_for);
                         units.push(bcx.units.intern(
                             pkg, target, profile, *kind, *mode, features, /*is_std*/ false,
                         ));

src/cargo/ops/cargo_compile.rs

@@ -34,7 +34,7 @@ use crate::core::compiler::{BuildConfig, BuildContext, Compilation, Context};
 use crate::core::compiler::{CompileKind, CompileMode, RustcTargetData, Unit};
 use crate::core::compiler::{DefaultExecutor, Executor, UnitInterner};
 use crate::core::profiles::{Profiles, UnitFor};
-use crate::core::resolver::features;
+use crate::core::resolver::features::{self, FeaturesFor};
 use crate::core::resolver::{HasDevUnits, Resolve, ResolveOpts};
 use crate::core::{LibKind, Package, PackageSet, Target};
 use crate::core::{PackageId, PackageIdSpec, TargetKind, Workspace};
@@ -750,7 +750,7 @@ fn generate_targets<'a>(
 
         let features = Vec::from(resolved_features.activated_features(
             pkg.package_id(),
-            false, // Root units are never build dependencies.
+            FeaturesFor::NormalOrDev, // Root units are never build dependencies.
         ));
         bcx.units.intern(
             pkg,
@@ -941,7 +941,7 @@ fn resolve_all_features(
     package_id: PackageId,
 ) -> HashSet<String> {
     let mut features: HashSet<String> = resolved_features
-        .activated_features(package_id, false)
+        .activated_features(package_id, FeaturesFor::NormalOrDev)
         .iter()
         .map(|s| s.to_string())
         .collect();
@@ -950,7 +950,11 @@ fn resolve_all_features(
     // required-features field when deciding whether to be built or skipped.
     for (dep_id, deps) in resolve_with_overrides.deps(package_id) {
         for dep in deps {
-            for feature in resolved_features.activated_features(dep_id, dep.is_build()) {
+            let features_for = match dep.is_build() {
+                true => FeaturesFor::BuildDep,
+                false => FeaturesFor::NormalOrDev,
+            };
+            for feature in resolved_features.activated_features(dep_id, features_for) {
                 features.insert(dep.name_in_toml().to_string() + "/" + &feature);
             }
         }