feat: implement workspace feature unification

Author: aliu

src/cargo/core/workspace.rs

@@ -307,9 +307,10 @@ impl<'gctx> Workspace<'gctx> {
                 }
             }
         }
-        if let CargoResolverConfig {
-            incompatible_rust_versions: Some(incompatible_rust_versions),
-        } = self.gctx().get::<CargoResolverConfig>("resolver")?
+        if let Some(incompatible_rust_versions) = self
+            .gctx()
+            .get::<CargoResolverConfig>("resolver")?
+            .incompatible_rust_versions
         {
             self.resolve_honors_rust_version =
                 incompatible_rust_versions == IncompatibleRustVersions::Fallback;

src/cargo/ops/cargo_compile/mod.rs

@@ -52,7 +52,9 @@ use crate::core::{PackageId, PackageSet, SourceId, TargetKind, Workspace};
 use crate::drop_println;
 use crate::ops;
 use crate::ops::resolve::WorkspaceResolve;
-use crate::util::context::{GlobalContext, WarningHandling};
+use crate::util::context::{
+    CargoResolverConfig, FeatureUnification, GlobalContext, WarningHandling,
+};
 use crate::util::interning::InternedString;
 use crate::util::{CargoResult, StableHasher};
 
@@ -272,13 +274,23 @@ pub fn create_bcx<'a, 'gctx>(
             HasDevUnits::No
         }
     };
+    let feature_unification = ws
+        .gctx()
+        .get::<CargoResolverConfig>("resolver")?
+        .feature_unification
+        .unwrap_or_default();
+    let resolve_specs = if let FeatureUnification::Workspace = feature_unification {
+        &Packages::All(Vec::new()).to_package_id_specs(ws)?
+    } else {
+        &specs
+    };
     let dry_run = false;
     let resolve = ops::resolve_ws_with_opts(
         ws,
         &mut target_data,
         &build_config.requested_kinds,
         cli_features,
-        &specs,
+        resolve_specs,
         has_dev_units,
         crate::core::resolver::features::ForceAllTargets::No,
         dry_run,

src/cargo/util/context/mod.rs

@@ -2745,6 +2745,7 @@ impl BuildTargetConfig {
 #[serde(rename_all = "kebab-case")]
 pub struct CargoResolverConfig {
     pub incompatible_rust_versions: Option<IncompatibleRustVersions>,
+    pub feature_unification: Option<FeatureUnification>,
 }
 
 #[derive(Debug, Deserialize, PartialEq, Eq)]
@@ -2754,6 +2755,14 @@ pub enum IncompatibleRustVersions {
     Fallback,
 }
 
+#[derive(Debug, Default, Deserialize)]
+#[serde(rename_all = "kebab-case")]
+pub enum FeatureUnification {
+    #[default]
+    Selected,
+    Workspace,
+}
+
 #[derive(Deserialize, Default)]
 #[serde(rename_all = "kebab-case")]
 pub struct TermConfig {

tests/testsuite/feature_unification.rs

@@ -0,0 +1,112 @@
+//! Tests for workspace feature unification.
+
+use cargo_test_support::prelude::*;
+use cargo_test_support::{project, str};
+
+#[cargo_test]
+fn feature_unification() {
+    let p = project()
+        .file(
+            ".cargo/config.toml",
+            r#"
+                [resolver]
+                feature-unification = "workspace"
+            "#,
+        )
+        .file(
+            "Cargo.toml",
+            r#"
+                [workspace]
+                resolver = "2"
+                members = ["common", "ab", "bc"]
+            "#,
+        )
+        .file(
+            "common/Cargo.toml",
+            r#"
+                [package]
+                name = "common"
+                version = "0.1.0"
+                edition = "2021"
+
+                [features]
+                a = []
+                b = []
+                c = []
+            "#,
+        )
+        .file(
+            "common/src/lib.rs",
+            r#"
+                pub fn features() {
+                    #[cfg(feature = "a")]
+                    print!("a");
+                    #[cfg(feature = "b")]
+                    print!("b");
+                    #[cfg(feature = "c")]
+                    print!("c");
+                }
+            "#,
+        )
+        .file(
+            "ab/Cargo.toml",
+            r#"
+                [package]
+                name = "ab"
+                version = "0.1.0"
+                edition = "2021"
+
+                [dependencies]
+                common = { path = "../common", features = ["a", "b"] }
+            "#,
+        )
+        .file("ab/src/main.rs", "fn main() { common::features(); }")
+        .file(
+            "bc/Cargo.toml",
+            r#"
+                [package]
+                name = "bc"
+                version = "0.1.0"
+                edition = "2021"
+
+                [dependencies]
+                common = { path = "../common", features = ["b", "c"] }
+            "#,
+        )
+        .file("bc/src/main.rs", "fn main() { common::features(); }")
+        .build();
+
+    p.cargo("build -p common")
+        .with_stderr_data(str![[r#"
+[COMPILING] common v0.1.0 ([ROOT]/foo/common)
+[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
+
+"#]])
+        .run();
+
+    // `common` should not be rebuilt when building `ab` or `bc`
+    p.cargo("build -p ab")
+        .with_stderr_data(str![[r#"
+[COMPILING] ab v0.1.0 ([ROOT]/foo/ab)
+[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
+
+"#]])
+        .run();
+    p.cargo("build -p bc")
+        .with_stderr_data(str![[r#"
+[COMPILING] bc v0.1.0 ([ROOT]/foo/bc)
+[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
+
+"#]])
+        .run();
+
+    p.cargo("build --workspace")
+        .with_stderr_data(str![[r#"
+[FINISHED] `dev` profile [unoptimized + debuginfo] target(s) in [ELAPSED]s
+
+"#]])
+        .run();
+
+    p.process(&p.bin("ab")).with_stdout_data(str!["abc"]).run();
+    p.process(&p.bin("bc")).with_stdout_data(str!["abc"]).run();
+}

tests/testsuite/main.rs

@@ -85,6 +85,7 @@ mod doc;
 mod docscrape;
 mod edition;
 mod error;
+mod feature_unification;
 mod features;
 mod features2;
 mod features_namespaced;