Pass full build_config to generate_targets()

diff --git a/src/cargo/ops/cargo_compile.rs b/src/cargo/ops/cargo_compile.rs
index 161d05a7bc6b5440c73c79c988760a5c49948ea3..3d78a3d759d71f79349b86cc532f1dacf6e46b6b 100644 (file)
--- a/src/cargo/ops/cargo_compile.rs
+++ b/src/cargo/ops/cargo_compile.rs
@@ -287,9 +287,8 @@ pub fn compile_ws<'a>(
         &to_builds,
         filter,
         default_arch_kind,
-        mode,
         &resolve_with_overrides,
-        release,
+        &build_config,
     )?;
 
     if let Some(args) = extra_args {
@@ -460,15 +459,14 @@ fn generate_targets<'a>(
     packages: &[&'a Package],
     filter: &CompileFilter,
     default_arch_kind: Kind,
-    mode: CompileMode,
     resolve: &Resolve,
-    release: bool,
+    build_config: &BuildConfig,
 ) -> CargoResult<Vec<Unit<'a>>> {
     let mut units = Vec::new();
 
     // Helper for creating a Unit struct.
     let new_unit = |pkg: &'a Package, target: &'a Target, target_mode: CompileMode| {
-        let profile_for = if mode.is_any_test() {
+        let profile_for = if build_config.mode.is_any_test() {
             // NOTE: The ProfileFor here is subtle.  If you have a profile
             // with `panic` set, the `panic` flag is cleared for
             // tests/benchmarks and their dependencies.  If we left this
@@ -519,7 +517,7 @@ fn generate_targets<'a>(
             ws.is_member(pkg),
             profile_for,
             target_mode,
-            release,
+            build_config.release,
         );
         // Once the profile has been selected for benchmarks, we don't need to
         // distinguish between benches and tests. Switching the mode allows
@@ -555,12 +553,17 @@ fn generate_targets<'a>(
             CompileFilter::Default {
                 required_features_filterable,
             } => {
-                let default_units = generate_default_targets(pkg.targets(), mode)
+                let default_units = generate_default_targets(pkg.targets(), build_config.mode)
                     .iter()
-                    .map(|t| (new_unit(pkg, t, mode), !required_features_filterable))
+                    .map(|t| {
+                        (
+                            new_unit(pkg, t, build_config.mode),
+                            !required_features_filterable,
+                        )
+                    })
                     .collect::<Vec<_>>();
                 proposals.extend(default_units);
-                if mode == CompileMode::Test {
+                if build_config.mode == CompileMode::Test {
                     // Include the lib as it will be required for doctests.
                     if let Some(t) = pkg.targets().iter().find(|t| t.is_lib() && t.doctested()) {
                         proposals.push((new_unit(pkg, t, CompileMode::Build), false));
@@ -577,7 +580,7 @@ fn generate_targets<'a>(
             } => {
                 if lib {
                     if let Some(target) = pkg.targets().iter().find(|t| t.is_lib()) {
-                        proposals.push((new_unit(pkg, target, mode), false));
+                        proposals.push((new_unit(pkg, target, build_config.mode), false));
                     } else if !all_targets {
                         bail!("no library targets found")
                     }
@@ -588,10 +591,10 @@ fn generate_targets<'a>(
                     FilterRule::All => Target::tested,
                     FilterRule::Just(_) => Target::is_test,
                 };
-                let test_mode = match mode {
+                let test_mode = match build_config.mode {
                     CompileMode::Build => CompileMode::Test,
                     CompileMode::Check { .. } => CompileMode::Check { test: true },
-                    _ => mode,
+                    _ => build_config.mode,
                 };
                 // If --benches was specified, add all targets that would be
                 // generated by `cargo bench`.
@@ -599,20 +602,22 @@ fn generate_targets<'a>(
                     FilterRule::All => Target::benched,
                     FilterRule::Just(_) => Target::is_bench,
                 };
-                let bench_mode = match mode {
+                let bench_mode = match build_config.mode {
                     CompileMode::Build => CompileMode::Bench,
                     CompileMode::Check { .. } => CompileMode::Check { test: true },
-                    _ => mode,
+                    _ => build_config.mode,
                 };
 
                 proposals.extend(
                     list_rule_targets(pkg, bins, "bin", Target::is_bin)?
                         .into_iter()
-                        .map(|(t, required)| (new_unit(pkg, t, mode), required))
+                        .map(|(t, required)| (new_unit(pkg, t, build_config.mode), required))
                         .chain(
                             list_rule_targets(pkg, examples, "example", Target::is_example)?
                                 .into_iter()
-                                .map(|(t, required)| (new_unit(pkg, t, mode), required)),
+                                .map(|(t, required)| {
+                                    (new_unit(pkg, t, build_config.mode), required)
+                                }),
                         )
                         .chain(
                             list_rule_targets(pkg, tests, "test", test_filter)?
@@ -631,7 +636,7 @@ fn generate_targets<'a>(
 
         // If any integration tests/benches are being run, make sure that
         // binaries are built as well.
-        if !mode.is_check() && proposals.iter().any(|&(ref unit, _)| {
+        if !build_config.mode.is_check() && proposals.iter().any(|&(ref unit, _)| {
             unit.mode.is_any_test() && (unit.target.is_test() || unit.target.is_bench())
         }) {
             proposals.extend(