Overhaul how cargo treats profiles

src/bin/bench.rs

@@ -50,20 +50,31 @@ pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
     let root = try!(find_root_manifest_for_cwd(options.flag_manifest_path));
     config.shell().set_verbose(options.flag_verbose);
 
+    let mut benches = Vec::new();
+    if let Some(s) = options.flag_bench {
+        benches.push(s);
+    }
+
     let ops = ops::TestOptions {
-        name: options.flag_bench.as_ref().map(|s| &s[..]),
         no_run: options.flag_no_run,
         compile_opts: ops::CompileOptions {
-            env: "bench",
             config: config,
             jobs: options.flag_jobs,
             target: options.flag_target.as_ref().map(|s| &s[..]),
-            dev_deps: true,
             features: &options.flag_features,
             no_default_features: options.flag_no_default_features,
             spec: options.flag_package.as_ref().map(|s| &s[..]),
-            lib_only: false,
             exec_engine: None,
+            release: true,
+            mode: ops::CompileMode::Bench,
+            filter: if benches.is_empty() {
+                ops::CompileFilter::Everything
+            } else {
+                ops::CompileFilter::Only {
+                    lib: false, bins: &[], examples: &[], tests: &[],
+                    benches: &benches,
+                }
+            },
         },
     };
 

src/bin/build.rs

@@ -47,28 +47,29 @@ the --release flag will use the `release` profile instead.
 ";
 
 pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
-    debug!("executing; cmd=cargo-build; args={:?}", env::args().collect::<Vec<_>>());
+    debug!("executing; cmd=cargo-build; args={:?}",
+           env::args().collect::<Vec<_>>());
     config.shell().set_verbose(options.flag_verbose);
 
     let root = try!(find_root_manifest_for_cwd(options.flag_manifest_path));
 
-    let env = if options.flag_release {
-        "release"
-    } else {
-        "compile"
-    };
-
     let opts = CompileOptions {
-        env: env,
         config: config,
         jobs: options.flag_jobs,
         target: options.flag_target.as_ref().map(|t| &t[..]),
-        dev_deps: false,
         features: &options.flag_features,
         no_default_features: options.flag_no_default_features,
         spec: options.flag_package.as_ref().map(|s| &s[..]),
-        lib_only: options.flag_lib,
         exec_engine: None,
+        mode: ops::CompileMode::Build,
+        release: options.flag_release,
+        filter: if options.flag_lib {
+            ops::CompileFilter::Only {
+                lib: true, bins: &[], examples: &[], benches: &[], tests: &[]
+            }
+        } else {
+            ops::CompileFilter::Everything
+        },
     };
 
     ops::compile(&root, &opts).map(|_| None).map_err(|err| {

src/bin/cargo.rs

@@ -105,7 +105,7 @@ fn execute(flags: Flags, config: &Config) -> CliResult<Option<()>> {
         // For the commands `cargo` and `cargo help`, re-execute ourselves as
         // `cargo -h` so we can go through the normal process of printing the
         // help message.
-        "" | "help" if flags.arg_args.len() == 0 => {
+        "" | "help" if flags.arg_args.is_empty() => {
             config.shell().set_verbose(true);
             let args = &["cargo".to_string(), "-h".to_string()];
             let r = cargo::call_main_without_stdin(execute, config, USAGE, args,

src/bin/doc.rs

@@ -46,19 +46,20 @@ pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
     let root = try!(find_root_manifest_for_cwd(options.flag_manifest_path));
 
     let mut doc_opts = ops::DocOptions {
-        all: !options.flag_no_deps,
         open_result: options.flag_open,
         compile_opts: ops::CompileOptions {
-            env: if options.flag_no_deps {"doc"} else {"doc-all"},
             config: config,
             jobs: options.flag_jobs,
             target: None,
-            dev_deps: false,
             features: &options.flag_features,
             no_default_features: options.flag_no_default_features,
             spec: options.flag_package.as_ref().map(|s| &s[..]),
-            lib_only: false,
             exec_engine: None,
+            filter: ops::CompileFilter::Everything,
+            release: false,
+            mode: ops::CompileMode::Doc {
+                deps: !options.flag_no_deps,
+            },
         },
     };
 

src/bin/run.rs

@@ -1,6 +1,5 @@
 use cargo::ops;
-use cargo::core::manifest::TargetKind;
-use cargo::util::{CliResult, CliError, human, Config};
+use cargo::util::{CliResult, CliError, Config};
 use cargo::util::important_paths::{find_root_manifest_for_cwd};
 
 #[derive(RustcDecodable)]
@@ -47,36 +46,35 @@ pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
     config.shell().set_verbose(options.flag_verbose);
     let root = try!(find_root_manifest_for_cwd(options.flag_manifest_path));
 
-    let env = match (options.flag_release, options.flag_example.is_some()) {
-        (true, _) => "release",
-        (false, true) => "test",
-        (false, false) => "compile"
-    };
+    let (mut examples, mut bins) = (Vec::new(), Vec::new());
+    if let Some(s) = options.flag_bin {
+        bins.push(s);
+    }
+    if let Some(s) = options.flag_example {
+        examples.push(s);
+    }
 
     let compile_opts = ops::CompileOptions {
-        env: env,
         config: config,
         jobs: options.flag_jobs,
         target: options.flag_target.as_ref().map(|t| &t[..]),
-        dev_deps: true,
         features: &options.flag_features,
         no_default_features: options.flag_no_default_features,
         spec: None,
-        lib_only: false,
         exec_engine: None,
-    };
-
-    let (target_kind, name) = match (options.flag_bin, options.flag_example) {
-        (Some(bin), None) => (TargetKind::Bin, Some(bin)),
-        (None, Some(example)) => (TargetKind::Example, Some(example)),
-        (None, None) => (TargetKind::Bin, None),
-        (Some(_), Some(_)) => return Err(CliError::from_boxed(
-            human("specify either `--bin` or `--example`, not both"), 1)),
+        release: options.flag_release,
+        mode: ops::CompileMode::Build,
+        filter: if examples.is_empty() && bins.is_empty() {
+            ops::CompileFilter::Everything
+        } else {
+            ops::CompileFilter::Only {
+                lib: false, tests: &[], benches: &[],
+                bins: &bins, examples: &examples,
+            }
+        },
     };
 
     let err = try!(ops::run(&root,
-                            target_kind,
-                            name,
                             &compile_opts,
                             &options.arg_args).map_err(|err| {
         CliError::from_boxed(err, 101)

src/bin/test.rs

@@ -9,6 +9,7 @@ struct Options {
     flag_jobs: Option<u32>,
     flag_manifest_path: Option<String>,
     flag_test: Option<String>,
+    flag_bin: Option<String>,
     flag_no_default_features: bool,
     flag_no_run: bool,
     flag_package: Option<String>,
@@ -24,7 +25,8 @@ Usage:
 
 Options:
     -h, --help               Print this message
-    --test NAME              Name of the test executable to run
+    --test NAME              Name of the integration test to run
+    --bin NAME               Name of the binary to run tests for
     --no-run                 Compile, but don't run tests
     -p SPEC, --package SPEC  Package to run tests for
     -j N, --jobs N           The number of jobs to run in parallel
@@ -52,20 +54,34 @@ pub fn execute(options: Options, config: &Config) -> CliResult<Option<()>> {
     let root = try!(find_root_manifest_for_cwd(options.flag_manifest_path));
     config.shell().set_verbose(options.flag_verbose);
 
+    let (mut tests, mut bins) = (Vec::new(), Vec::new());
+    if let Some(s) = options.flag_test {
+        tests.push(s);
+    }
+    if let Some(s) = options.flag_bin {
+        bins.push(s);
+    }
+
     let ops = ops::TestOptions {
-        name: options.flag_test.as_ref().map(|s| &s[..]),
         no_run: options.flag_no_run,
         compile_opts: ops::CompileOptions {
-            env: "test",
             config: config,
             jobs: options.flag_jobs,
             target: options.flag_target.as_ref().map(|s| &s[..]),
-            dev_deps: true,
             features: &options.flag_features,
             no_default_features: options.flag_no_default_features,
             spec: options.flag_package.as_ref().map(|s| &s[..]),
-            lib_only: false,
             exec_engine: None,
+            release: false,
+            mode: ops::CompileMode::Test,
+            filter: if tests.is_empty() && bins.is_empty() {
+                ops::CompileFilter::Everything
+            } else {
+                ops::CompileFilter::Only {
+                    lib: false, examples: &[], benches: &[],
+                    tests: &tests, bins: &bins,
+                }
+            }
         },
     };