Add -Zfeatures=all option.

Author: ehuss

src/cargo/core/resolver/features.rs

@@ -72,6 +72,11 @@ impl FeatureOpts {
                     "build_dep" => opts.decouple_build_deps = true,
                     "dev_dep" => opts.decouple_dev_deps = true,
                     "itarget" => opts.ignore_inactive_targets = true,
+                    "all" => {
+                        opts.decouple_build_deps = true;
+                        opts.decouple_dev_deps = true;
+                        opts.ignore_inactive_targets = true;
+                    }
                     "compare" => opts.compare = true,
                     "ws" => unimplemented!(),
                     "host" => unimplemented!(),

src/doc/src/reference/unstable.md

@@ -537,5 +537,7 @@ The available options are:
   is, dev dependency features will still be unified if you run commands like
   `cargo test` or `cargo build --all-targets`.
 
+* `all` — Enable all feature options (`itarget,build_dep,dev_dep`).
+
 * `compare` — This option compares the resolved features to the old resolver,
   and will print any differences.

tests/testsuite/features2.rs

@@ -683,3 +683,85 @@ fn cyclical_dev_dep() {
         .masquerade_as_nightly_cargo()
         .run();
 }
+
+#[cargo_test]
+fn all_feature_opts() {
+    // All feature options at once.
+    Package::new("common", "1.0.0")
+        .feature("normal", &[])
+        .feature("build", &[])
+        .feature("dev", &[])
+        .feature("itarget", &[])
+        .file(
+            "src/lib.rs",
+            r#"
+            pub fn feats() -> u32 {
+                let mut res = 0;
+                if cfg!(feature="normal") { res |= 1; }
+                if cfg!(feature="build") { res |= 2; }
+                if cfg!(feature="dev") { res |= 4; }
+                if cfg!(feature="itarget") { res |= 8; }
+                res
+            }
+            "#,
+        )
+        .publish();
+
+    let p = project()
+        .file(
+            "Cargo.toml",
+            r#"
+            [package]
+            name = "foo"
+            version = "0.1.0"
+            edition = "2018"
+
+            [dependencies]
+            common = {version = "1.0", features=["normal"]}
+
+            [dev-dependencies]
+            common = {version = "1.0", features=["dev"]}
+
+            [build-dependencies]
+            common = {version = "1.0", features=["build"]}
+
+            [target.'cfg(whatever)'.dependencies]
+            common = {version = "1.0", features=["itarget"]}
+            "#,
+        )
+        .file(
+            "src/main.rs",
+            r#"
+            fn main() {
+                expect();
+            }
+
+            fn expect() {
+                let expected: u32 = std::env::var("EXPECTED_FEATS").unwrap().parse().unwrap();
+                assert_eq!(expected, common::feats());
+            }
+
+            #[test]
+            fn from_test() {
+                expect();
+            }
+            "#,
+        )
+        .build();
+
+    p.cargo("run").env("EXPECTED_FEATS", "15").run();
+
+    // Only normal feature.
+    p.cargo("run -Zfeatures=all")
+        .masquerade_as_nightly_cargo()
+        .env("EXPECTED_FEATS", "1")
+        .run();
+
+    p.cargo("test").env("EXPECTED_FEATS", "15").run();
+
+    // only normal+dev
+    p.cargo("test -Zfeatures=all")
+        .masquerade_as_nightly_cargo()
+        .env("EXPECTED_FEATS", "5")
+        .run();
+}