Auto merge of #1441 - alexcrichton:issue-1323, r=bson

This commit is a complete overhaul of how Cargo handles compilation profiles
internally. The external interface of Cargo is not affected by this change.

Previously each Target had a Profile embedded within it. Conceptually a Target
is an entry in the manifest (a binary, benchmark, etc) and a Profile controlled
various flags (e.g. --test, -C opt-level, etc). Each Package then contained many
profiles for each possible compilation mode. For example a Package would have
one target for testing a library, benchmarking a library, documenting a library,
etc. When it came to building these targets, Cargo would filter out the targets
listed to determine what needed to be built.

This filtering was largely done based off an "environment" represented as a
string. Each mode of compilation got a separate environment string like `"test"`
or `"bench"`. Altogether, however, this approach had a number of drawbacks:

* Examples in release mode do not currently work. This is due to how examples
  are classified and how release mode is handled (e.g. the "release" environment
  where examples are meant to be built in the "test" environment).
* It is not trivial to implement `cargo test --release` today.
* It is not trivial to implement `cargo build --bin foo` where *only* the binary
  `foo` is built. The same is true for examples.
* It is not trivial to add selective building of a number of
  binaries/examples/etc.
* Filtering the list of targets to build has some pretty hokey logic that
  involves pseudo-environments like "doc-all" vs "doc". This logic is duplicated
  in a few places and in general is quite brittle.
* The TOML parser greatly affects compilation due to the time at which profiles
  are generated, which seems somewhat backwards.
* Profiles must be overridden, but only partially, at compile time becuase only
  the top-level package's profile is applied.

In general, this system just needed an overhaul. This commit made a single
change of separating `Profile` from `Target` and then basically hit `make` until
all the tests passed again. The other large architectural changes are:

* Environment strings are now entirely gone.
* Filters are implemented in a much more robust fashion.
* Release mode is now handled much more gracefully.
* The unit of compilation in the backend is no longer (package, target) but
  rather (package, target, profile). This change had to be propagated many
  location in the `cargo_rustc` module.
* The backend does not filter targets to build *at all*. All filtering now
  happens entirely in the frontend.

I'll test issues after this change lands, but the motivation behind this is to
open the door to quickly fixing a number of outstanding issues against Cargo.
This change itself is not intended to close many bugs.

Author: bors

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,
+                }
+            }
         },
     };